rom-distillery 0.1

data/lib/distillery/rom/path.rb

@@ -0,0 +1,110 @@
+# SPDX-License-Identifier: EUPL-1.2
+
+module Distillery
+class ROM
+
+# @abstract Abstract class used for ROM path    
+class Path
+
+    # Path value as string.
+    #
+    # @return [String]
+    #
+    def to_s
+        raise NotImplementedError
+    end
+
+    # File directly accessible on the file system
+    #
+    # @return [String]
+    #
+    def file
+        raise NotImplementedError
+    end
+
+
+    # File or directory that is considered the storage space for entries
+    #
+    # @return [String]
+    #
+    def storage
+        raise NotImplementedError
+    end
+
+
+    # Entry
+    #
+    # @return [String]
+    #
+    def entry
+        raise NotImplementedError
+    end
+
+
+    # Get path basename
+    #
+    # @return [String]
+    #
+    def basename
+        raise NotImplementedError
+    end
+
+    
+    # ROM reader
+    # @note Can be costly, prefer existing #copy if possible
+    #
+    # @yieldparam [#read] io		stream for reading
+    #
+    # @return block value
+    #
+    def reader(&block)
+        raise NotImplementedError
+    end
+
+
+    # Copy ROM content to the filesystem, possibly using link if requested.
+    #
+    # @param to    [String]		file destination
+    # @param length [Integer,nil]	data length to be copied
+    # @param offset [Integer]		data offset
+    # @param force [Boolean]		remove previous file if necessary
+    # @param link  [:hard, :sym, nil]	use link instead of copy if possible
+    #
+    # @return [Boolean]			status of the operation
+    #
+    def copy(to, length = nil, offset = 0, force: false, link: :hard)
+        raise NotImplementedError
+    end
+
+    
+    # Rename ROM and physical content.
+    #
+    # @note Renaming could lead to silent removing if same ROM is on its way
+    #
+    # @param path  [String]		new ROM path
+    # @param force [Boolean]		remove previous file if necessary
+    #
+    # @return [Boolean]			status of the operation
+    #
+    def rename(path, force: false)
+        raise NotImplementedError
+    end
+
+
+    # Delete physical content.
+    #
+    # @return [Boolean]
+    #
+    def delete!
+        raise NotImplementedError
+    end
+end
+
+end
+end
+
+
+
+require_relative 'path/virtual'
+require_relative 'path/archive'
+require_relative 'path/file'

data/lib/distillery/rom/path/archive.rb

@@ -0,0 +1,103 @@
+# SPDX-License-Identifier: EUPL-1.2
+
+module Distillery
+class ROM
+class Path
+
+# Path from archive, binding archive and entry together.
+class Archive < Path
+
+    # @!visibility private
+    @@separator = '#'
+
+    
+    # Set the separator used to distinguish archive file from entry
+    #
+    # @param sep	[String]	separator
+    #
+    def self.separator=(sep)
+        @@separator = sep.dup.freeze
+    end
+
+    
+    # Get the separator used to distinguish archive file from entry
+    #
+    # @return [String,Array]
+    #
+    def self.separator
+        @@separator
+    end
+
+    
+    # Create a an Archive Path instance
+    #
+    # @param archive [ROMArchive]	archive instance
+    # @param entry   [String]		archive entry
+    #
+    def initialize(archive, entry)
+        @archive = archive
+        @entry   = entry
+    end
+
+    # (see ROM::Path#to_s)
+    def to_s(separator = nil)
+        separator ||= @@separator
+        "#{self.file}#{separator[0]}#{self.entry}#{separator[1]}"
+    end
+
+    # (see ROM::Path#file)
+    def file
+        @archive.file
+    end
+    
+    # (see ROM::Path#storage)
+    def storage
+        self.file
+    end
+
+    # (see ROM::Path#entry)
+    def entry
+        @entry
+    end
+
+    # (see ROM::Path#basename)
+    def basename
+        ::File.basename(self.entry)
+    end
+
+    # (see ROM::Path#grouping)
+    def grouping
+        [ self.storage, self.entry, @archive.size ]
+    end
+    
+    # (see ROM::Path#reader)
+    def reader(&block)
+        @archive.reader(@entry, &block)
+    end
+
+    # (see ROM::Path#copy)
+    def copy(to, length = nil, offset = 0, force: false, link: :hard)
+        # XXX: improve like String
+        @archive.extract(@entry, to, length, offset, force: force)
+    end
+    
+    # (see ROM::Path#rename)
+    def rename(path, force: false)
+        # XXX: improve like String
+        @archive.rename(@entry, path, force: force)
+    end
+    
+    # (see ROM::Path#delete!)
+    def delete!
+        @archive.delete!(@entry)
+    end
+
+    # Returns the value of attribute archive
+    # @return [ROMArchive]
+    attr_reader :archive
+
+end
+
+end
+end
+end

data/lib/distillery/rom/path/file.rb

@@ -0,0 +1,100 @@
+# SPDX-License-Identifier: EUPL-1.2
+
+module Distillery
+class ROM
+class Path
+
+# Path from a file
+class File < Path
+    # Returns a new instance of File.
+    #
+    # @param entry   [String]		path to file in basedir
+    # @param basedir [String, nil]	base directory
+    #
+    def initialize(entry, basedir=nil)
+        if entry.start_with?('/')
+            raise ArgumentError, "entry must be relative to basedir"
+        end
+            
+        @entry   = entry
+        @basedir = basedir || '.'
+    end
+
+    # (see ROM::Path#to_s)
+    def to_s
+        self.file
+    end
+
+    # (see ROM::Path#file)
+    def file
+        if @basedir == '.'
+        then @entry
+        else ::File.join(@basedir, @entry)
+        end
+    end
+    
+    # (see ROM::Path#storage)
+    def storage
+        @basedir
+    end
+
+    # (see ROM::Path#entry)
+    def entry
+        @entry
+    end
+
+    # (see ROM::Path#basename)
+    def basename
+        ::File.basename(@entry)
+    end
+
+    # (see ROM::Path#reader)
+    def reader(&block)
+        ::File.open(self.file, ::File::RDONLY, binmode: true, &block)
+    end
+
+    # (see ROM#copy)
+    def copy(to, length = nil, offset = 0, force: false, link: :hard)
+        (!force && length.nil? && offset.zero? &&
+         ::File.exists?(to) && self.same?(ROM.from_file(to))) ||
+            ROM.filecopy(self.file, to, length, offset,
+                         force: force, link: link)
+    end
+    
+    # (see ROM#rename)
+    def rename(path, force: false)
+        case path
+        when String
+        else raise ArgumentError, "unsupport path type (#{path.class})"
+        end
+
+
+        file = if path.start_with?('/')
+               then path
+               else ::File.join(@basedir, path)
+               end
+
+        if !::File.exists?(file)
+            ::File.rename(self.file, file) == 0
+        elsif self.same?(ROM.from_file(file))
+            ::File.unlink(self.file) == 1
+        elsif force
+            ::File.rename(self.file, file) == 0
+        else
+            false
+        end
+    rescue SystemCallError
+        false
+    end
+    
+    # (see ROM#delete!)
+    def delete!
+        ::File.unlink(self.file) == 1
+    rescue SystemCallError
+        false
+    end
+end
+
+end
+end
+end

data/lib/distillery/rom/path/virtual.rb

@@ -0,0 +1,70 @@
+# SPDX-License-Identifier: EUPL-1.2
+
+module Distillery
+class ROM
+class Path
+
+# Path without physical implementation. 
+# Used for ROM defined in DAT file
+class Virtual < Path
+    # @param entry [String]
+    def initialize(entry)
+        if ! entry.kind_of?(String)
+            raise ArgumentError
+        end
+        @entry = entry
+    end
+
+    # (see ROM::Path#to_s)
+    def to_s
+        @entry
+    end
+
+    # (see ROM::Path#file)
+    def file
+        nil
+    end
+    
+    # (see ROM::Path#storage)
+    def storage
+        nil
+    end
+
+    # (see ROM::Path#entry)
+    def entry
+        @entry
+    end
+
+    # (see ROM::Path#basename)
+    def basename
+        ::File.basename(@entry)
+    end
+
+    # (see ROM::Path#reader)
+    def reader(&block)
+        nil
+    end
+
+    # (see ROM::Path#copy)
+    def copy(to, length = nil, offset = 0, force: false, link: :hard)
+        false
+    end
+
+    # (see ROM::Path#rename)
+    def rename(path, force: false)
+        case path
+        when String then @entry = path
+        else raise ArgumentError, "unsupport path type (#{path.class})"
+        end
+        true
+    end
+
+    # (see ROM::Path#delete!)
+    def delete!
+        true
+    end
+end
+
+end
+end
+end

data/lib/distillery/storage.rb

@@ -0,0 +1,170 @@
+# SPDX-License-Identifier: EUPL-1.2
+
+require_relative 'vault'
+
+module Distillery
+    
+class Storage
+    include Enumerable
+
+    # Hidden ROMs directory
+    ROMS_DIR  = '.roms'
+
+    # Hidden games directory
+    GAMES_DIR = '.games'
+    
+    def initialize(vault)
+        @roms  = vault
+    end
+
+
+    def headered
+        @roms.headered
+    end
+
+    def each
+        block_given? ? @roms.each {|r| yield(r) }
+                     : @roms.each
+    end
+
+    def index(type = nil, separator = nil)
+        type ||= ROM::FS_CHECKSUM
+        each.map {|rom|
+            hash = rom.cksum(type, :hex)
+            file = case path = rom.path
+                   when ROM::Path::Archive then path.to_s(separator)
+                   else                         path.to_s
+                   end
+            [ hash, file ]
+        }
+    end
+    
+    def build_roms_directory(dest, pristine: false, force: false, delete: false)
+        block = if delete
+                    proc {|rom| rom.delete! }
+                end
+        @roms.save(dest,
+                   part: :rom, subdir: true, pristine: pristine, force: force,
+                   &block)
+        self
+    end
+    
+    def build_games(dat, vault, &block)
+        dat.games.each {|game|
+            puts "Building: #{game}"
+            
+            game.roms.each {|rom|
+                # Find in the matching ROM in the storage vault
+                # Note that in the vault:
+                #   - the same ROM can be present multiple time
+                #   - all checksums are defined
+                match = Array(vault.match(rom)).uniq {|r| r.cksum(FS_CHECKSUM) }
+
+                # Sanity check
+                if    match.size > 1
+                    # Due to weak ROM definition in DAT file
+                    puts "- multiple matching ROMs for #{rom} (IGNORING)"
+                    next
+                elsif match.size == 0
+                    # Sadly we don't have this ROM
+                    puts "- no mathing ROM for #{rom} (IGNORING)"
+                    next
+                end
+
+                # Get vault ROM
+                vrom = match.first
+
+                # Call block
+                block.call(game.name, vrom, rom.path.entry)
+            }
+        }
+    end
+
+    
+    def build_games_directories(dir, dat, vault, pristine: false, force: false)
+        # Directory
+        Dir.unlink(dir) if     pristine		# Create clean env if requested
+        Dir.mkdir(dir)  unless Dir.exist?(dir)	# Ensure directory exists
+
+        # Build game directories
+        build_games(dat, vault) {|game, rom, dst|
+            rom.copy(File.join(dir, game, dst))
+        }
+    end
+
+    
+    def build_games_archives(dir, dat, vault, type = '7z', pristine: false)
+        # Normalize to lower case
+        type = type.downcase
+
+        # Directory
+        Dir.unlink(dir) if     pristine		# Create clean env if requested
+        Dir.mkdir(dir)  unless Dir.exist?(dir)	# Ensure directory exists
+
+        # Ensure we support this type of archive
+        if ! ROMArchive::EXTENSIONS.include?(type)
+            raise ArgumentError, "unsupported type (#{type})"
+        end
+
+        # Build game archives
+        build_games(dat, vault) {|game, rom, dst|
+            file = File.join(dir, "#{game}.#{type}")
+            Distillery::Archiver.for(file).writer(dst) {|o|
+                rom.reader {|i|
+                    while data = i.read(32 * 1024)
+                        o.write(data)
+                    end
+                }
+            }
+        }
+    end
+    
+
+    
+    def rename(dat)
+        @roms.each {|rom|
+            # Skip if ROM is not present in DAT ?
+            if (m = dat.roms.match(rom)).nil?
+                puts "No DAT rom matching <#{rom}>"
+                next
+            end
+
+            # Find new rom name
+            name = if m.size == 1
+                       # Easy, take the DAT rom name if different
+                       next if m.first.name == rom.name
+                       m.first.name
+                   else
+                       # Find name in the DAT, that is not currently present
+                       # in our vault for this rom. 
+                       match_name = m.map {|r| r.name }
+                       roms_name  = @roms.match(rom).map {|r| r.name}
+                       lst_name   = match_name - roms_name
+
+                       # Check if all DAT names are present in our vault,
+                       # but perhaps we have an extra name to be removed
+                       if lst_name.empty?
+                           if (roms_name - match_name).include?(rom.name)
+                               rom.delete!
+                           end
+                           next
+                       end
+
+                       # Use the first name
+                       lst_name.first
+                   end
+
+            # Apply new name. (Will be a no-op if same name)
+            rom.rename(name) {|old_name, new_name|
+                puts "  < #{old_name}"
+                puts "  > #{new_name}"
+            }
+        }
+    end
+
+    
+    attr_reader :roms
+end
+
+end
+