rom-distillery 0.1

data/lib/distillery/datfile.rb

@@ -0,0 +1,180 @@
+# SPDX-License-Identifier: EUPL-1.2
+
+require 'set'
+require 'nokogiri'
+
+require_relative 'error'
+require_relative 'game'
+require_relative 'rom'
+require_relative 'vault'
+
+module Distillery
+
+# Handle information from DAT file
+class DatFile
+    class ContentError < Error
+    end
+    
+    # List of ROM with loosely defined (ie: with some missing checksum)
+    #
+    # @return [Array<ROM>,nil]
+    #
+    def with_partial_checksum
+        @roms.with_partial_checksum
+    end
+
+    
+    # Get Games to which this ROM belongs.
+    # @note This only works for ROMs created by the DatFile
+    #
+    # @param rom [Rom]
+    #
+    # @return [Array<Game>]
+    #
+    def getGames(rom)
+        @roms_game[rom.object_id]
+    end
+
+    
+    # Create DatFile representation from file.
+    #
+    # @param datfile [String]
+    #
+    def initialize(datfile)
+        @games     = Set.new
+        @roms      = Vault::new
+        @roms_game = {}
+
+        if !FileTest.file?(datfile)
+            raise ArgumentError, "DAT file is missing or not a regular file"
+        end
+        
+        # Get datafile as XML document
+        dat = Nokogiri::XML(File.read(datfile))
+
+        dat.xpath('//header').each {|hdr|
+            @name        = hdr.xpath('name'       )&.first&.content
+            @description = hdr.xpath('description')&.first&.content
+            @url         = hdr.xpath('url'        )&.first&.content
+            @date        = hdr.xpath('date'       )&.first&.content
+            @version     = hdr.xpath('version'    )&.first&.content
+        }
+        
+        # Process each game elements
+        dat.xpath('//game').each {|g|
+            releases = g.xpath('release').map {|r|
+                Release::new(r[:name], region: r[:region].upcase)
+            }
+            roms     = g.xpath('rom').map {|r|
+                path = File.join(r[:name].split('\\'))
+                ROM::new(ROM::Path::Virtual.new(path),
+                         :size  => Integer(r[:size]),
+                         :crc32 => r[:crc ],
+                         :md5   => r[:md5 ],
+                         :sha1  => r[:sha1])
+            }
+            game     = Game::new(g['name'], *roms, releases: releases,
+                                                    cloneof: g['cloneof'])
+
+            roms.each {|rom|
+                (@roms_game[rom.object_id] ||= []) << game
+                @roms << rom
+            }
+
+            if @games.add?(game).nil?
+                raise ContentError,
+                      "Game '#{game}' defined multiple times in DAT file"
+            end
+        }
+    end
+
+    # Identify ROM which have the same fullname/name but are different
+    #
+    # @param type [:fullname, :name]	Check by fullname or name
+    #
+    # @return [Hash{String => Array<ROM>}]
+    #
+    def clash(type = :fullname)
+        grp = case type
+              when :fullname then @roms.each.group_by {|rom| rom.fullname      }
+              when :name     then @roms.each.group_by {|rom| rom.name          }
+              else raise ArgumentError
+              end
+
+        grp.select           {|_, roms| roms.size > 1 }
+           .transform_values {|roms|
+            lst = []
+            while rom = roms.first do
+                t, f = roms.partition {|r| r.same?(rom) }
+                lst << t.first
+                roms = f
+            end
+            lst
+        }
+    end
+
+
+    # @return [Vault]
+    attr_reader :roms
+
+    
+    # Iterate over each ROM
+    #
+    # @yieldparam rom [ROM]
+    #
+    # @return [self,Enumerator]
+    #
+    def each_rom
+        block_given? ? @roms.each {|r| yield(r) }
+                     : @roms.each
+    end
+
+
+    # @return [Set<Games>]
+    attr_reader :games
+
+    
+    # Iterate over each game
+    #
+    # @yieldparam game [Game]
+    #
+    # @return [self,Enumerator]
+    #
+    def each_game
+        block_given? ? @games.each {|g| yield(g) }
+                     : @games.each
+    end
+
+
+    # Datfile name
+    #
+    # @return [String,nil]
+    attr_reader :name
+
+    
+    # Datfile description
+    #
+    # @return [String,nil]
+    attr_reader :description
+
+    
+    # Datfile url
+    #
+    # @return [String,nil]
+    attr_reader :url
+
+    
+    # Datfile date
+    #
+    # @return [String,nil]
+    attr_reader :date
+
+    
+    # Datfile version
+    #
+    # @return [String,nil]
+    attr_reader :version
+    
+end
+
+end

data/lib/distillery/error.rb

@@ -0,0 +1,13 @@
+# SPDX-License-Identifier: EUPL-1.2
+
+module Distillery
+
+# Assertion
+class Assert < StandardError
+end
+
+# Error
+class Error < StandardError
+end
+
+end

data/lib/distillery/game.rb

@@ -0,0 +1,70 @@
+# SPDX-License-Identifier: EUPL-1.2
+
+require_relative 'game/release'
+
+module Distillery
+    
+# Information about game
+#
+class Game
+    # Create a new instance of Game.
+    # 
+    # @param name     [String]
+    # @param roms     [ROM]
+    # @param releases [Array<Game::Release>,nil]
+    # @param cloneof  [String,nil]
+    def initialize(name, *roms, releases: nil, cloneof: nil)
+        raise ArgumentError if name.nil?
+
+        @name     = name
+        @roms     = roms
+        @releases = releases
+        @cloneof  = cloneof
+    end
+
+    
+    # @return [Integer]
+    def hash
+        @name.hash
+    end
+
+    def eql?(o)
+        @name.eql?(o.name)
+    end
+
+
+    # String representation
+    # @return [String]
+    def to_s
+        @name
+    end
+
+
+    # @return [String]
+    attr_reader :name
+
+    # @return [Array<ROM>]
+    attr_reader :roms
+
+    # @return [Array<Release>]
+    attr_reader :releases
+
+    # @return [String]
+    attr_reader :cloneof
+
+
+    # Iterate over ROMs used be the game
+    #
+    # @yieldparam rom [ROM]
+    #
+    # @return [self,Enumerator]
+    #
+    def each_rom
+        block_given? ? @roms.each {|r| yield(r) }
+                     : @roms.each
+    end
+
+    
+end
+
+end 

data/lib/distillery/game/release.rb

@@ -0,0 +1,40 @@
+# SPDX-License-Identifier: EUPL-1.2
+
+module Distillery
+
+# Information about release
+#
+class Release
+    # @!visibility private
+    @@regions = Set.new
+
+    # List all assigned region code.
+    #
+    # @return [Set<String>]		set of region code
+    #
+    def self.regions
+        @@regions
+    end
+
+    # Create a new instance of Release.
+    #
+    # @param name   [String]		release name
+    # @param region [String]		region of release
+    #
+    def initialize(name, region:)
+        @name   = name
+        @region = region
+        
+        @@regions.add(region)
+    end
+
+    # Release name
+    # @return [String]
+    attr_reader :name
+
+    # Region of release
+    # @return [String]
+    attr_reader :region
+end
+
+end

data/lib/distillery/refinements.rb

@@ -0,0 +1,41 @@
+# SPDX-License-Identifier: EUPL-1.2
+
+module Distillery
+
+module StringY
+    refine ::String do
+        def ellipsize(width, position = :end, ellipsis: '...')
+            # Sanity check
+            unless [ :begin, :middle, :end ].include?(position)
+                raise ArgumentError, "unsupported position (#{position})"
+            end
+            
+            # Is there a need to ellipsize ?
+            return self if self.size <= width
+
+            # Ellipsis too big?
+            if ellipsis&.size > width
+                return ellipsis
+            end
+
+            # Deal with nil-ellipsis 
+            ellipsis ||= ''
+
+            # Perform ellipsis
+            str     = self.dup
+            delsize = self.size - width + ellipsis.size
+
+            case position
+            when :begin  then str[0, delsize]       = ellipsis
+            when :middle then str[width/2, delsize] = ellipsis
+            when :end    then str[-delsize .. -1]   = ellipsis
+            end
+
+            # Return ellipsized string
+            str
+        end
+    end
+    
+end
+
+end

data/lib/distillery/rom-archive.rb

@@ -0,0 +1,266 @@
+# SPDX-License-Identifier: EUPL-1.2
+
+require 'set'
+
+begin
+    require 'mimemagic'
+rescue LoadError
+end
+
+require_relative 'archiver'
+require_relative 'archiver/external'
+require_relative 'archiver/zip'
+require_relative 'rom'
+
+Distillery::Archiver.registering
+
+
+
+module Distillery
+
+# Deal with ROM embedded in an archive file.
+#    
+class ROMArchive
+    include Enumerable
+
+    # Prefered
+    PREFERED   = '7z'
+    
+    # Allowed extension names
+    EXTENSIONS = Set[ '7z', 'zip' ]
+
+    
+    # Set buffer size used when processing archive content
+    #
+    # @param size [Integer] 		size in kbytes
+    #
+    def self.bufsize=(size)
+        @@bufsize = size << 10
+    end
+
+    
+    # Check using extension if file is an archive
+    #
+    # @param file [String] 		file to test
+    #
+    # @return [Boolean]
+    #
+    def self.archive?(file, archives: EXTENSIONS)
+        return false if archives.nil?
+        archives.include?(File.extname(file)[1..-1])
+    end
+
+    
+    # Read ROM archive from file
+    #
+    # @param file [String]		path to archive file
+    # @param headers [Array,nil,false]  header definition list
+    #
+    # @return [ROMArchive]
+    #
+    def self.from_file(file, headers: nil)
+        # Create archive object
+        archive = self.new(file)
+
+        # 
+        Distillery::Archiver.for(file).each {|entry, i|
+            path = ROM::Path::Archive.new(archive, entry)
+            archive[entry] = ROM.new(path, **ROM.info(i, headers: headers))
+        }
+
+        archive
+    end
+
+    
+    # Create an empty archive
+    #
+    # @param file [String]		archive file
+    #
+    def initialize(file)
+        @file   = file
+        @roms   = {}
+    end
+
+    
+    # String representation of the archive
+    # @return [String]
+    def to_s
+        @file
+    end
+
+    
+    # Assign a ROM to the archive
+    #
+    # @param entry [String] 		archive entry name
+    # @param rom   [ROM] 		ROM
+    #
+    # @return [ROM]			the assigned ROM
+    #
+    def []=(entry, rom)
+        @roms.merge!(entry => rom) {|key, old_rom, new_rom|
+            warn "replacing ROM entry \"#{key}\" (#{to_s})"
+            new_rom
+        }
+        rom
+    end
+
+        
+    # Same archive file
+    #
+    # @param o [ROMArchive]		other archive
+    # @return [Boolean]
+    #
+    def same_file?(o)
+        self.file == o.file
+    end
+
+
+    # Test if archive is identical (same file, same content)
+    #
+    # @param o [ROMArchive]		other archive
+    # @return [Boolean]
+    #
+    def ==(o)
+        o.kind_of?(ROMArchive) 						&&
+            (self.entries.to_set == o.entries.to_set) 			&&
+            self.entries.all? {|entry| self[entry].same?(o[entry]) }
+    end
+
+    
+    # Archive size (number of entries)
+    # @return [Integer]
+    def size
+        @roms.size
+    end
+
+    
+    # Iterate over each ROM
+    #
+    # @yieldparam rom [ROM]
+    #
+    # @return [self,Enumerator]
+    #
+    def each
+        block_given? ? @roms.each_value {|r| yield(r) }
+                     : @roms.each_value
+    end
+    
+    # List of ROMs
+    #
+    # @return [Array<ROM>]
+    #
+    def roms
+        @roms.values
+    end
+
+    
+    # List of archive entries
+    #
+    # @return [Array<String>]
+    #
+    def entries
+        @roms.keys
+    end
+
+    
+    # Get ROM by entry
+    #
+    # @param entry [String]		archive entry
+    # @return [ROM]
+    #
+    def [](entry)
+        @roms[entry]
+    end
+
+    
+    # Delete entry
+    #
+    # @param entry [String]		archive entry
+    #
+    # @return [Boolean]			operation status
+    #
+    def delete!(entry)
+        Distillery::Archiver.for(@file) {|archive|
+            if archive.delete!(entry)
+                if archive.empty?
+                    File.unlink(@file)
+                end
+                true
+            else
+                false
+            end
+        }
+    end
+
+    
+    # Read ROM.
+    # @note Can be costly, to be avoided.
+    #
+    # @param entry [String]		archive entry
+    #
+    # @yieldparam [#read] io		stream for reading
+    #
+    # @return block value
+    #
+    def reader(entry, &block)
+        Distillery::Archiver.for(@file).reader(entry, &block)
+    end
+
+    
+    # Extract rom to the filesystem
+    #
+    # @param entry  [String]		entry (rom) to extract
+    # @param to     [String]		destination
+    # @param length [Integer,nil]	data length to be copied
+    # @param offset [Integer]		data offset
+    # @param force  [Boolean]		remove previous file if necessary
+    #
+    # @return [Boolean]			operation status
+    #
+    def extract(entry, to, length = nil, offset = 0, force: false)
+        Distillery::Archiver.for(@file).reader(entry) {|i|
+            # Copy file
+            begin
+                op = force ? File::TRUNC : File::EXCL
+                File.open(to, File::CREAT|File::WRONLY|op) {|o|
+                    while (skip = [ offset, @@bufsize ].min) > 0
+                        i.read(skip)
+                        offset -= skip
+                    end
+
+                    if length.nil?
+                        while data = i.read(@@bufsize)
+                            o.write(data)
+                        end
+                    else
+                        while ((sz = [ length, @@bufsize ].min) > 0) &&
+                              (data = i.read(sz))
+                            o.write(data)
+                            length -= sz
+                        end
+                    end
+                }
+            rescue Errno::EEXIST
+                return false
+            end
+            
+            # Assuming entries are unique
+            return true
+        }
+        
+        # Was not found
+        return false
+    end
+    
+    
+    # Archive file
+    # @return [String]
+    attr_reader :file
+end
+
+
+# Set default buffer size to 32k
+ROMArchive.bufsize = 32
+
+
+end