Code:
#--------------------------------------------------------------------------
# * Benötigte Methoden
#--------------------------------------------------------------------------
class Class
#--------------------------------------------------------------------------
# * Erzeugt alternative Namen für eine Methode -KD
#--------------------------------------------------------------------------
def link(methode, *namen)
namen.each {|n| define_method(n) {|*a| method(methode).call(*a)}}
end
def link_classmethod(methode, *namen)
$methode = methode
namen.each {|n|
$n = n
class << self
methode, n = $methode, $n
define_method(n) {|*a| self.method(methode).call(*a)}
end
}
$methode = nil
$n = nil
end
end
class Array
#--------------------------------------------------------------------------
# * Addiert zwei Arrays ohne doppelte o. leere Elemente hinzuzufügen -KD
#--------------------------------------------------------------------------
def add(*args)
args.each {|e| push(e) unless include?(e) or e.empty?}
end
end
class Hash
#--------------------------------------------------------------------------
# * Sucht nach einem passenden Key für einen Value/Suchblock -KD
#--------------------------------------------------------------------------
def key_for_value(search_value)
key = nil
ergebnis = each_pair {|key, value|
break if if block_given? then
yield(value, search_value)
else
value == search_value
end
true
}
if ergebnis then false else key end
end
end
class Symbol
#--------------------------------------------------------------------------
# * Macht ein Symbol zu einem Instanzvariablensymbol -KD
#--------------------------------------------------------------------------
def to_isym
return ('@' + self.to_s).to_sym
end
end
class Fixnum
#--------------------------------------------------------------------------
# * Liefert einen String mit einer n-stellen Zahl. -KD
#--------------------------------------------------------------------------
def zu_nstelligen_string(n)
vor = ""
(n-1).downto(0) {|stelle| vor = vor.concat('0') if self < 10**stelle }
vor.concat(self.to_s)
end
end
class Float
#--------------------------------------------------------------------------
# * Gibt Datengröße an. -KD
#--------------------------------------------------------------------------
EINHEITEN = ["byte", "kb", "mb", "gb"]
def datasize
size = self; counter = 0
while counter < EINHEITEN.size-1 and (a=size / 1024) >= 0.1
size = a; counter += 1;
end
size.to_s + ' ' + EINHEITEN[counter]
end
end
class File
#--------------------------------------------------------------------------
# * Überprüft, ob der Dateiname auf eine Ressourcendatei zeigt -KD
#--------------------------------------------------------------------------
def self.ressource?(pfad, *possible_endings)
pfad =~ /.+\.(.+)/
!(possible_endings.find {|e| e == $1}).nil?
end
#--------------------------------------------------------------------------
# * Erzeugt einen Ordner - WATANABE, Hirofumi (Ruby Standard Library)
#--------------------------------------------------------------------------
def self.makedirs(*dirs)
verbose = if dirs[-1].is_a? String then false else dirs.pop end
mode = 0755
for dir in dirs
parent = dirname(dir)
next if parent == dir or directory? dir
makedirs parent unless directory? parent
$stderr.print "mkdir ", dir, "\n" if verbose
if basename(dir) != ""
begin
Dir.mkdir dir, mode
rescue SystemCallError
raise unless directory? dir
end
end
end
end
#--------------------------------------------------------------------------
# * Sucht nach Dateien - (Ruby Standard Library)
#--------------------------------------------------------------------------
def self.find(*paths)
paths.collect!{|d| d.dup}
while file = paths.shift
catch(:prune) do
yield file.dup.taint
next unless File.exist? file
begin
if File.lstat(file).directory? then
d = Dir.open(file)
begin
for f in d
next if f == "." or f == ".."
if File::ALT_SEPARATOR and
file =~ /^(?:[\/\\]|[A-Za-z]:[\/\\]?)$/ then
f = file + f
elsif file == "/" then
f = "/" + f
else
f = File.join(file, f)
end
paths.unshift f.untaint
end
ensure
d.close
end
end
rescue Errno::ENOENT, Errno::EACCES
end
end
end
end
def self.prune
throw :prune
end
#--------------------------------------------------------------------------
# * Kopiert Dateien -Ruby Standard Library
#--------------------------------------------------------------------------
BUFSIZE = 8 * 1024
def self.catname(from, to)
if directory? to
join to.sub(%r([/\\]$), ''), basename(from)
else
to
end
end
def self.syscopy(from, to)
to = catname(from, to)
fmode = stat(from).mode
tpath = to
not_exist = !exist?(tpath)
from = open(from, "rb")
to = open(to, "wb")
begin
while true do to.syswrite from.sysread(BUFSIZE) end
rescue EOFError
ret = true
rescue
ret = false
ensure
to.close
from.close
end
chmod(fmode, tpath) if not_exist
ret
end
end
Teil 2
Code:
#==============================================================================
# ** Ressourcen - von KD
#------------------------------------------------------------------------------
# Diese Klasse speichert Ressourcennamen und liest diese aus Projekten aus
#==============================================================================
class Ressourcen
include(Enumerable)
#--------------------------------------------------------------------------
# * Konstanten
#--------------------------------------------------------------------------
ORDNER = "Data/" #Ordner wo die Daten sich befinden
MAPS = "Map" #Dateiname der Maps
ENDUNG = ".rxdata" #Dateiendung der Daten
LOGPFAD = "/log/" #Pfad der Logdateien
LOGNAME = "ressourcen" #Dateiname der Logdatei
LOGENDING = '.log' #Dateiendung der Logdateien
LOESCHPFAD = "/nicht_benoetigt/" #Pfad für verschobene Ressourcendateien
#Konstanten für den Automatik-Vorgang
LOGGEN = true #Genutzte Ressourcen werden geloggt
MULTI_FILE = false #Ressourcen werden in mehreren Textdateien geloggt
LOG_UNUSED = true #Ungenutzte Ressourcen werden extra geloggt
LOESCHEN = false #nicht benötigte Ressourcen werden gelöscht
EXIT = true #Nach Ausführen des Vorgangs wird Programm beendet
LOG_ORDNER = '/unused/'#Logordner für ungenutzte Ressourcen
UNUSEDNAME = 'unused' #Dateiname für ungenutzte-Ressourcenlogdatei
#--------------------------------------------------------------------------
# * Attribute
#--------------------------------------------------------------------------
METADIRECTORY = Hash.new
METADIRECTORY['graphics'] = [:characters, :windowskins, :transitions,
:fogs, :battlebacks, :panoramas, :windowskins, :characters,
:animations, :autotiles, :battlers, :gameovers, :icons,
:pictures, :tilesets, :titles]
METADIRECTORY['audio'] = [:se, :bgs, :me, :bgm]
TYPEN = METADIRECTORY.values.flatten
#Attribut Readers -> Metadirectories, Typen, root
METADIRECTORY.each_key {|meta| define_method(meta.to_sym) {
result = Array.new
METADIRECTORY[meta].each {|m| result << self.method(m).call}
result.flatten
}}
attr_reader(:root, *TYPEN)
#============================================================================
# ***Initialisierung der Instanzvariablen***
# root#String : Gibt den Pfad zum Projektordner an
#============================================================================
def initialize(root='.')
TYPEN.each {|typ|
self.instance_variable_set(typ.to_isym, Array.new)
}
@root = root
end
#============================================================================
# ***Klassenmethoden***
#============================================================================
#--------------------------------------------------------------------------
# * Definiert Dateiendungen für einen Typ o. Metaordner
# klassifizierung#String/Symbol : Metaordner oder Typ der Dateiendung
# *extensions#Strings : Name der Dateiendung
#--------------------------------------------------------------------------
@@extensions = Hash.new
def self.extensions_for(klassifizierung, *extensions)
k = klassifizierung.to_s.downcase
if @@extensions[k] then
@@extensions[k].add(extensions)
else
@@extensions[k] = extensions
end
end
#--------------------------------------------------------------------------
# * Erzeugt Dateiendungen
#--------------------------------------------------------------------------
extensions_for('audio', 'mid', 'ogg', 'wav', 'mp3', 'wma')
extensions_for('graphics', 'png', 'bmp', 'jpg')
#--------------------------------------------------------------------------
# * Gib Dateiendungen für bestimmten Typ/Metaordner zurück => Array
# typ#String/Symbol : Metaordner oder Typ, der gesuchte Dateiendung hat
# Standardmäßig werden alle Dateiendungen ausgegeben
#--------------------------------------------------------------------------
def self.extensions(typ=true)
if (typ==true) then return @@extensions.values.flatten end
key = typ.to_s.downcase
if @@extensions.has_key?(key) then
@@extensions[key]
elsif @@extensions.has_key?(n=metadirectory_for(typ).to_s.downcase)
@@extensions[n]
else
[]
end
end
def extensions(t=true); Ressourcen.extensions(t); end
#--------------------------------------------------------------------------
# * Gibt den Metaordner für einen Typ aus => nil oder String
# typ#Symbol : Typ, dessen Metaordner gesucht wird
#--------------------------------------------------------------------------
def self.metadirectory_for(typ)
if typ then
typ = typ.to_s.downcase.to_sym
METADIRECTORY.key_for_value(typ) {|h, s| h.include?(s)}
else
nil
end
end
def metadirectory_for(typ); Ressourcen.metadirectory_for(typ); end
#--------------------------------------------------------------------------
# * Sucht nach Ressourcen, loggt diese und löscht ggf. nicht benötigte
#--------------------------------------------------------------------------
def self.automatik()
ressourcen = genutzte_ressourcen.sort!
if MULTI_FILE then ressourcen.loggen else ressourcen.loggen_one end if LOGGEN
if LOG_UNUSED or LOESCHEN then
unused = Ressourcen.ungenutzte_ressourcen(ressourcen)
end
if LOG_UNUSED then
if MULTI_FILE then
unused.loggen(LOG_ORDNER)
else
unused.loggen_one(LOGPFAD, UNUSEDNAME)
end
end
if LOESCHEN then unused.verschiebe end
exit if EXIT
end
#--------------------------------------------------------------------------
# * Erzeugt Construktor-Methoden
# methode#Symbol : Methode, für die ein Constructor erzeugt wird
#--------------------------------------------------------------------------
def self.constructor(methode)
$methode = methode
class << self; m = $methode; define_method(m) {|*a|
root=if a[0].class==String and self.instance_method(m).arity.abs < a.size
a.shift else "."
end
r = self.new(root)
r.method(m).call(*a)
r
} end
$methode = nil
end
#--------------------------------------------------------------------------
# * Erzeugt Constructor und alternative Methodennamen
# name#Symbol : Methode, die behandelt wird
# *alternatives#Symbole : Alternative Methodennamen
#--------------------------------------------------------------------------
def self.constructor_and_alternatives(name, *alternatives)
constructor(name) #erzeuge Konstructor für Methode
link(name, *alternatives) #alternative namen für Methode
link_classmethod(name, *alternatives) #alternative namen für Konstruktor
end
#============================================================================
# ***Constructor Methoden*** => Ressourcenobjekt
# Als Klassenmethoden genutzt erzeugen sie neue Ressourcen-Objekte
# root#String : Erzeugt ein Ressourcenobjekt in diesem Projektordner
# Als Instanzmethoden genutzt fügen sie dem Objekt neue Ressourcen hinzu
#============================================================================
#--------------------------------------------------------------------------
# * Erzeugt ein Ressourcenobjekt aus genutzten Ressourcen eines Projektes
#--------------------------------------------------------------------------
def genutzte_ressourcen()
durchsuche_maps
durchsuche_database
self
end
constructor_and_alternatives(:genutzte_ressourcen, :used_ressources)
#--------------------------------------------------------------------------
# * Erzeugt ein Ressourcenobjekt aus importierten Ressourcen eines Projektes
#--------------------------------------------------------------------------
def importierte_ressourcen()
pfad = @root + '/'
#Durchsuche alle Metaordner
directories = METADIRECTORY.keys.collect {|e| pfad + e.to_s}
dirs = ""
METADIRECTORY.keys.each {|d| dirs = dirs.concat('|' + d.to_s)}
dirs = dirs.sub('|', '')
pfad = ' ' + pfad
while a = pfad =~ /[^\\]\./ do pfad[a+1] = '\\.' end
while a = pfad =~ /[^\\]\// do pfad[a+1] = '\\/' end
pfad[0] = ''
regexp = Regexp.new(pfad+"(#{dirs})"+'\/(.+)\/(.+)\..+', true)
File.find(*directories) {|pfad|
#Wenn gefundene Datei die passende Dateiendung hat....
pfad =~ regexp
if File.ressource?(pfad.downcase, *extensions($2)) then
#...soll sie in die Liste aufgenommen werden
if method(methode=$2.downcase.to_sym) then
method(methode).call.add($3)
end
end
}
self
end
constructor_and_alternatives(:importierte_ressourcen, :imported_ressources)
#--------------------------------------------------------------------------
# * Erzeugt ein Ressourcenobjekt aus nichtbenötigten Ressourcen des Projektes
# genutzte#Ressourcen : Prozess lässt sich beschleunigen, wenn das
# genutzte-Ressourcenobjekt zuvor schon erzeugt wurde
#--------------------------------------------------------------------------
def ungenutzte_ressourcen(genutzte=nil)
genutzte = Ressourcen.genutzte_ressourcen(@root) unless genutzte
importierte_ressourcen()
drop(genutzte)
end
constructor_and_alternatives(:ungenutzte_ressourcen, :unused_ressources)
#--------------------------------------------------------------------------
# * Erzeugt ein Ressourcenobjekt aus einer Map
# mapdateiname#String : Pfad zur Mapdatei
#--------------------------------------------------------------------------
def durchsuche_map(mappfad)
map = load_data(@root+'/'+mappfad)
#Suche aus der Map alle Sounddateien heraus
bgm.add(map.bgm.name) if map.autoplay_bgm
bgm.add(map.bgs.name) if map.autoplay_bgs
#Suche aus der Map alle Eventgrafiken heraus
events = map.events
events.each_value {|event|
event.pages.each {|page|
characters.add(page.graphic.character_name)
#Suche alle Ressourcen aus MoveBefehlen heraus
durchsuche_moveroute(page.move_route.list)
#Suche alle Ressourcen aus Eventbefehlen heraus
durchsuche_eventcommands(page.list)
}
}
self
end
constructor_and_alternatives(:durchsuche_map, :scan_map)
#--------------------------------------------------------------------------
# * Erzeugt ein Ressourcenobjekt aus den Mapdaten
#--------------------------------------------------------------------------
def durchsuche_maps
#Suche in den Maps nach verwendeten Ressourcen
i = 1
name = ORDNER + MAPS+i.zu_nstelligen_string(3)+ENDUNG
while File.exist?(@root + "/" + name)
durchsuche_map(name)
i += 1
name = ORDNER + MAPS+i.zu_nstelligen_string(3)+ENDUNG
end
self
end
constructor_and_alternatives(:durchsuche_maps, :scan_maps)
#--------------------------------------------------------------------------
# * Erzeugt ein Ressourcenobjekt aus den Move-Routes
# move_list#RPG::MoveCommand-Array : Move-Commands die durchsucht werden
#--------------------------------------------------------------------------
def durchsuche_moveroute(move_liste)
move_liste.each {|befehl|
case befehl.code
when 41
characters.add(befehl.parameters[0])
when 44
bgs.add(befehl.parameters[0].name)
when 45
durchsuche_script(befehl.parameters[0])
end
}
self
end
constructor_and_alternatives(:durchsuche_moveroute, :scan_moveroute)
#--------------------------------------------------------------------------
# * Erzeugt ein Ressourcenobjekt aus den Event Commands
# liste#RPG::EventCommand-Array : EventCommands die durchsucht werden
#--------------------------------------------------------------------------
def durchsuche_eventcommands(liste)
rubystring = ""
messagestring = ""
commentstring = ""
liste.each {|befehl|
case befehl.code
when 101, 401
messagestring += "\n" + befehl.parameters[0]
when 108, 408
commentstring += "\n" + befehl.parameters[0]
when 111
if befehl.parameters[4] == 12
rubystring + "\n" + befehl.parameters[1]
end
when 131
windowskins.add(befehl.parameters[0])
when 132
bgm.add(befehl.parameters[0].name)
when 133
me.add(befehl.parameters[0].name)
when 204
case befehl.parameters[0]
when 0 then panoramas.add(befehl.parameters[1])
when 1 then fogs.add(befehl.parameters[1])
when 2 then battlebacks.add(befehl.parameters[1])
end
when 209
durchsuche_moveroute(befehl.parameters[1].list)
when 222
transitions.add(befehl.parameters[0])
when 231
pictures.add(befehl.parameters[1])
when 241
bgm.add(befehl.parameters[0].name)
when 245
bgs.add(befehl.parameters[0].name)
when 249
me.add(befehl.parameters[0].name)
when 250
se.add(befehl.parameters[0].name)
when 322
characters.add(befehl.parameters[1])
battlers.add(befehl.parameters[3])
when 355
rubystring.concat(befehl.parameters[0])
when 655
rubystring.concat(befehl.parameters[0])
end
}
durchsuche_script(rubystring)
durchsuche_message(messagestring)
durchsuche_comment(commentstring)
self
end
constructor_and_alternatives(:durchsuche_eventcommands, :scan_eventcommands)
#--------------------------------------------------------------------------
# * Erzeugt ein Ressourcenobjekt aus den Rubyscripts (unvollständig)
# string#String : String aus Rubyscripten, der durchsucht wird
#--------------------------------------------------------------------------
def durchsuche_script(string)
self
end
constructor_and_alternatives(:durchsuche_script, :scan_script)
#--------------------------------------------------------------------------
# * Erzeugt ein Ressourcenobjekt aus den Messagescripts (unvollständig)
# string#String : String aus Messages, der durchsucht wird
#--------------------------------------------------------------------------
def durchsuche_message(string)
self
end
constructor_and_alternatives(:durchsuche_script, :scan_script)
#--------------------------------------------------------------------------
# * Erzeugt ein Ressourcenobjekt aus den Commentcripts (unvollständig)
# string#String : String aus Comments, der durchsucht wird
#--------------------------------------------------------------------------
def durchsuche_comment(string)
self
end
constructor_and_alternatives(:durchsuche_script, :scan_script)
#--------------------------------------------------------------------------
# * Erzeugt ein Ressourcenobjekt aus den Informationen der Database
#--------------------------------------------------------------------------
def durchsuche_database
#Actors
datei = load_data("#{@root}/Data/Actors.rxdata")
datei.each {|actor|
next unless actor
characters.add(actor.character_name)
battlers.add(actor.battler_name)
}
#Skills und Items
datei = load_data("#{@root}/Data/Skills.rxdata") +
load_data("#{@root}/Data/Items.rxdata")
datei.each {|e|
next unless e
icons.add(e.icon_name)
se.add(e.menu_se.name)
}
#Weapons und armors
datei = load_data("#{@root}/Data/Weapons.rxdata") +
load_data("#{@root}/Data/Armors.rxdata")
datei.each {|e|
next unless e
icons.add(e.icon_name)
}
#Enemies
datei = load_data("#{@root}/Data/Enemies.rxdata")
datei.each {|e|
next unless e
battlers.add(e.battler_name)
}
#Battle-Events
datei = load_data("#{@root}/Data/Troops.rxdata")
datei.each {|e|
next unless e
e.pages.each {|page|
durchsuche_eventcommands(page.list)
}
}
#Animations
datei = load_data("#{@root}/Data/Animations.rxdata")
datei.each {|e|
next unless e
animations.add(e.animation_name)
e.timings.each {|time| se.add(time.se.name)}
}
#Tilesets
datei = load_data("#{@root}/Data/Tilesets.rxdata")
datei.each {|e|
next unless e
tilesets.add(e.tileset_name)
autotiles.add(*e.autotile_names)
panoramas.add(e.panorama_name)
fogs.add(e.fog_name)
battlebacks.add(e.battleback_name)
}
#CommonEvents
datei = load_data("#{@root}/Data/CommonEvents.rxdata")
datei.each {|e|
next unless e
durchsuche_eventcommands(e.list)
}
#System
datei = load_data("#{@root}/Data/System.rxdata")
windowskins.add(datei.windowskin_name)
titles.add(datei.title_name)
gameovers.add(datei.gameover_name)
windowskins.add(datei.windowskin_name)
transitions.add(datei.battle_transition)
bgm.add(datei.title_bgm.name)
bgm.add(datei.battle_bgm.name)
me.add(datei.battle_end_me.name)
me.add(datei.gameover_me.name)
se.add(datei.cursor_se.name)
se.add(datei.decision_se.name)
se.add(datei.cancel_se.name)
se.add(datei.buzzer_se.name)
se.add(datei.equip_se.name)
se.add(datei.shop_se.name)
se.add(datei.save_se.name)
se.add(datei.load_se.name)
se.add(datei.battle_start_se.name)
se.add(datei.escape_se.name)
se.add(datei.actor_collapse_se.name)
se.add(datei.enemy_collapse_se.name)
battlebacks.add(datei.battleback_name)
battlers.add(datei.battler_name)
self
end
constructor_and_alternatives(:durchsuche_database, :scan_database)
#============================================================================
# ***Öffentliche Instanzmethoden***
#============================================================================
#--------------------------------------------------------------------------
# * Sortiert ein Ressourcenobjekt => Ressourcen
#--------------------------------------------------------------------------
def sort!
TYPEN.each {|typ|
array = self.instance_variable_get(typ.to_isym)
array.sort!
}
self
end
#--------------------------------------------------------------------------
# * Gibt jene Ressourcentypen zurück, die nicht leer sind => Symbol-Array
#--------------------------------------------------------------------------
def typen
TYPEN.find_all {|t| !self.instance_variable_get(t.to_isym).empty?}
end
#--------------------------------------------------------------------------
# * Addition zweier Ressourcenobjekte => Ressourcen
# other#Ressourcen : Summant, mit dem das Ressourcenobjekt addiert wird
#--------------------------------------------------------------------------
def concat(other)
TYPEN.each {|typ|
typ = typ.to_isym
self.instance_variable_get(typ).add(*other.instance_variable_get(typ))
}
self
end
#--------------------------------------------------------------------------
# * Subtraktion zweier Ressourcenobjekte => Ressourcen
# other#Ressourcen : Subtrahend , mit dem subtrahiert wird
#--------------------------------------------------------------------------
def drop(other)
TYPEN.each {|typ|
typ = typ.to_isym
v = self.instance_variable_get(typ) - other.instance_variable_get(typ)
self.instance_variable_set(typ, v)
}
self
end
#--------------------------------------------------------------------------
# * Schnittmenge zweier Ressourcenobjekte => Ressourcen
# other#Ressourcen : Vergleichsressourcenobjekt
#--------------------------------------------------------------------------
def compare(other)
ressi = Ressourcen.new(@root)
TYPEN.each {|typ| ressi.method(typ).call.add(
*method(typ).call & other.method(typ).call)
}
ressi
end
#--------------------------------------------------------------------------
# * Loggt die Ressourcen in verschiedenen Textdateien
# ordner#String : Pfad zum Log-Ordner
# dateiende#String : Dateiende der Logdateien
#--------------------------------------------------------------------------
def loggen(ordner=LOGPFAD, dateiende=LOGENDING)
File.makedirs(@root + '/' + ordner)
TYPEN.each {|typ|
liste = self.instance_variable_get(typ.to_isym)
next if liste.empty?
File.open(path + ordner + typ.to_s + dateiende, 'w+') {|file|
liste.each {|name|
file.write(name + "\n")
}
}
}
end
#--------------------------------------------------------------------------
# * Loggt die Ressourcen in einer Textdatei
# ordner#String : Pfad zum Log-Ordner
# dname#String : Name der Logdatei
# dateiende#String : Dateiende der Logdatei
#--------------------------------------------------------------------------
def loggen_one(ordner=LOGPFAD, dname=LOGNAME, dateiende=LOGENDING)
File.makedirs(@root+'/' + ordner)
sortierer = Proc.new {|a,b| a.to_s <=> b.to_s}
File.open(@root + '/' + ordner + dname + dateiende, 'w+') {|file|
TYPEN.sort(&sortierer).each {|typ|
liste = self.instance_variable_get(typ.to_isym)
next if liste.empty?
file.write(typ.to_s.capitalize + "\n")
liste.each {|name|
file.write(name + "\n")
}
file.write("\n")
}
}
end
#--------------------------------------------------------------------------
# * Erzeugt die Ordner und ermitteln dest und src Pfade (Privat!)
#--------------------------------------------------------------------------
def ordner_erzeugen(path, *args, &block)
#Iteriere jeden Metaordner
METADIRECTORY.each_pair {|ordner, typen|
next if method(ordner.to_sym).call.empty?
#Lege einen Ordner für diesen META an, falls noch nicht geschehen
File.makedirs(dest_pfad = (path+'/'+ordner.capitalize))
src_pfad = @root + '/' + ordner.capitalize
#Iteriere die Typen jedes Metaordners
typen.each {|typ|
next if (inhalt=method(typ).call).empty?
styp = typ.to_s.capitalize
#Lege einen Ordner für diesen Typ an, falls noch nicht geschehen
File.makedirs(dest_typpfad = dest_pfad + '/' + styp)
src_typpfad = src_pfad + '/' + styp
#Iteriere die Ressourcen eines Types
inhalt.each {|e|
#Ermittle vollständigen Dateinamen der Ressource
src_name = src_typpfad + "/" + e
endung = ""
next if Ressourcen.extensions(typ).each {|endung|
if File.exist?(src_name + '.' + endung) then break end
}
src_name = src_name + '.' + endung
dest_name = dest_typpfad + '/' + e + '.' + endung
#Führe den Proc aus
block.call(src_name, dest_name, *args)
}
}
}
end
private(:ordner_erzeugen)
#--------------------------------------------------------------------------
# * Verschiebt Ressourcen in einen extra Ordner
# lpfad#String : Pfad zum Ordner, zu dem verschoben wird
#--------------------------------------------------------------------------
def verschiebe(lpfad=LOESCHPFAD)
lpfad = lpfad.root if lpfad.instance_of?(Ressourcen)
ordner_erzeugen(@root + '/' + lpfad) {|src, dest|
File.rename(File.expand_path(src), File.expand_path(dest))
}
end
link(:verschiebe, :move)
#--------------------------------------------------------------------------
# * Kopiert Ressourcen in ein anderes Projekt
# zielpfad#String/Ressourcen : Zielordner, in das Ressourcen kopiert werden
# Ressourcenobjekt, in dessen Root kopiert wird
#--------------------------------------------------------------------------
def kopiere(zielpfad)
zielpfad = zielpfad.root if zielpfad.instance_of?(Ressourcen)
ordner_erzeugen(zielpfad) {|src, dest|
File.syscopy(File.expand_path(src), File.expand_path(dest))
}
end
#--------------------------------------------------------------------------
# * Erhält Größe der Ressourcendateien => String o. Float
#--------------------------------------------------------------------------
def size(special=false) #=> gibt Float zurück
groesse = 0
self.each(special) {|r| groesse += FileTest.size(path(r)) }
groesse.to_f
end
def printable_size(special=false) #=> gibt einen lesbaren String zurück
size(special).datasize
end
#--------------------------------------------------------------------------
# * Sucht Pfad einer Datei => String
# name#String : Name der gesuchten Datei
# typ#Symbol : Typ der gesuchten Datei
# meta#String : Metaordner, in dem sich die Datei befindet
# endung#String : Endung der Datei
# Angaben bis auf name können weggelassen werden, verzögern aber den Prozess
#--------------------------------------------------------------------------
def path(name, typ=false, meta=false, endung=false)
dmeta = if meta then meta elsif typ then meta(typ) else meta(name) end
dtyp = (if typ then typ else typ(name) end).to_s
return false unless (dmeta and dtyp)
path = "#{@root}/#{dmeta}/#{dtyp}/#{name}"
dendung = if endung then endung else endung(name, dtyp.to_sym, dmeta) end
return false unless dendung
path + '.' + dendung
end
#--------------------------------------------------------------------------
# * Sucht Metaordner einer Datei => String
# angabe#String/Symbol: Entweder Dateiname oder Dateityp
#--------------------------------------------------------------------------
def meta(angabe)
typ = if TYPEN.include?(angabe.to_sym) then angabe else typ(angabe) end
Ressourcen.metadirectory_for(typ)
end
#--------------------------------------------------------------------------
# * Sucht Typ einer Datei => Symbol
# name#String: Dateiname
#--------------------------------------------------------------------------
def typ(name)
typ = nil
if (TYPEN.each {|typ| break if method(typ).call.include?(name)}).nil? then
typ else nil end
end
#--------------------------------------------------------------------------
# * Sucht Endung einer Datei => String
# name#String : Dateiname
# typ#Symbol : Typ der gesuchten Datei
# meta#String : Metaordner der Datei
# Angaben bis auf name können weggelassen werden, verzögern aber den Prozess
#--------------------------------------------------------------------------
def endung(name, typ=false, meta=false)
typ = typ(name) unless typ
meta = meta(typ) unless meta
path = "#{@root}/#{meta}/#{typ}/#{name}"
e = nil
if (Ressourcen.extensions(typ).each {|e|
if File.exist?(path + '.' + e) then break end
}) then nil else e
end
end
#--------------------------------------------------------------------------
# * Gibt alle Pfade aus, die den Angaben entsprechen => String-Array
# dname#String: Dateiname; dtyp#Symbol : Dateityp; dmeta#String : Metaordner
# dendung#String : Endung der Datei
# Wenn Angaben weggelassen werden, werden alle Pfade ausgegeben
# Wenn Block angegeben, werden die einzelnen Pfade iteriert
#--------------------------------------------------------------------------
def paths(dname=false, dtyp=false, dmeta=false, dendung=false)
typen = if dtyp then dtyp.to_a
elsif dmeta then METADIRECTORY[dmeta]
else typen()
end
result = Array.new
typen.each {|typ|
method(typ).call.each {|name|
if dendung or (dendung = endung(name, typ)) then
result << path(name, typ, false, dendung)
end
}
}
result.each{|e| yield(e)} if block_given?
result
end
#--------------------------------------------------------------------------
# * Iteriert Ressourcennamen (Enumerable Modul)
# special#Symbol/String : Nur Inhalt des Metaordners/Typs wird iteriert
# Wenn kein special angegeben, wird jeder Ressourcenname iteriert
#--------------------------------------------------------------------------
def each(special=false, &block)
if special then
self.method(special.to_sym).call.each(&block)
else
(TYPEN.collect {|typ| self.method(typ).call}).flatten.each(&block)
end
end
end
Berechtigungen
Zitieren