rom-distillery 0.1

data/lib/distillery/vault.rb

@@ -0,0 +1,433 @@
+# SPDX-License-Identifier: EUPL-1.2
+
+require 'set'
+require 'pathname'
+require 'fileutils'
+require 'find'
+
+require_relative 'rom'
+require_relative 'rom-archive'
+
+module Distillery
+
+class Vault
+    include Enumerable
+
+    # @!visibility private
+    GLOB_PATTERN_REGEX = /(?<!\\)[?*}{\[\]]/
+
+    # List of ROM checksums
+    CHECKSUMS    = ROM::CHECKSUMS
+
+    # List of archives extensions
+    ARCHIVES     = ROMArchive::EXTENSIONS
+
+    # List of files to be ignored
+    IGNORE_FILES = Set[ '.dat', '.missing', '.baddump', '.extra' ]
+
+    # List of directories to be ignored
+    IGNORE_DIRS  = Set[ '.roms', '.games', '.trash' ]
+
+    # Directory pruning
+    DIR_PRUNING  = Set[ '.dat' ]
+
+
+    # Potential ROM from directory.
+    # @note file in {IGNORE_FILES}, directory in {IGNORE_DIRS}, 
+    #       directories holding a {DIR_PRUNING} file or starting with a
+    #       dot are ignored      
+    #
+    # @param dir       [String] 	path to directory
+    # @param depth     [Integer,nil]	exploration depth
+    #
+    # @yieldparam file [String]		file being processed
+    # @yieldparam dir: [String]		directory relative to
+    #
+    def self.from_dir(dir, depth: nil)
+        Find.find(dir) do |path|
+            basename = File.basename(path)
+            subpath  = Pathname(path).relative_path_from(dir).to_s
+            if    FileTest.directory?(path)
+                next       if path == dir
+                Find.prune if IGNORE_DIRS.include?(basename)
+                Find.prune if basename.start_with?('.')
+                Find.prune if !depth.nil? &&
+                              subpath.split(File::Separator).size > depth
+                Find.prune if DIR_PRUNING.any? {|f| File.exists?(f) }
+            elsif FileTest.file?(path)
+                next if IGNORE_FILES.include?(basename)                
+                yield(subpath, dir: dir) if block_given?
+            end
+        end
+    end
+
+    
+    # Potential ROM from glob
+    # @note file in {IGNORE_FILES}, directory in {IGNORE_DIRS}, 
+    #       directories holding a {DIR_PRUNING} file or starting with a
+    #       dot are ignored      
+    #
+    # @param glob     [String]		ruby glob
+    # @param basedir  [:guess,nil]	basedir to use when interpreting glob
+    #                                   matching
+    #
+    # @yieldparam file [String]		file being processed
+    # @yieldparam dir: [String]		directory relative to
+    #
+    def self.from_glob(glob, basedir: :guess)
+        if basedir == :guess
+            gentry  = glob.split(File::SEPARATOR)
+            idx     = gentry.find_index{|entry| entry =~ GLOB_PATTERN_REGEX }
+            gentry  = gentry[0,idx]
+            basedir = if    gentry.empty?       then nil
+                      elsif gentry.first.empty? then '/'
+                      else                      File.join(gentry)
+                      end
+        end
+
+        # Build file list (reject ignored files and dirs)
+        lst = Dir[glob].reject {|path|
+            (! FileTest.file?(path)) 				||
+            IGNORE_FILES.include?(File.basename(path)) 		||
+            path.split(File::SEPARATOR)[0..-1].any? {|dir|
+                IGNORE_DIRS.include?(dir) || dir.start_with?('.')
+            }
+        }
+        # Build cut list based on directory prunning
+        cutlst = lst.map {|f| File.dirname(f) }.uniq.select {|f|
+            DIR_PRUNING.any? {|p| FileTest.exist?(File.join(f,p)) }
+        }
+        # Apply cut list
+        lst.reject! {|path|
+            cutlst.any? {|cut| path.start_with?("#{cut}#{File::SEPARATOR}") }
+        }
+
+        # Iterate on list
+        lst.each do |path|
+            subpath = if basedir.nil?
+                      then path
+                      else Pathname(path).relative_path_from(basedir).to_s
+                      end
+            yield(subpath, dir: basedir) if block_given?
+        end
+    end
+
+    
+    def initialize(roms = [])
+        @cksum    = Hash[CHECKSUMS.map {|k| [ k, {} ] }]
+        @roms     = []
+            
+        Array(roms).each {|rom| add_rom(rom) }
+    end
+
+    # @return [Boolean]
+    def empty?
+        @roms.empty?
+    end
+
+    # @return [Integer]
+    def size
+        @roms.size
+    end
+    
+    # Iterate over each ROM
+    #
+    # @yieldparam rom [ROM]
+    #
+    # @return [self,Enumerator]
+    #
+    def each
+        block_given? ? @roms.each {|r| yield(r) }
+                     : @roms.each
+    end
+
+    # Construct a new ROM vault as the intersection
+    #
+    # @param o [Vault]	ROM vault to intersect with self
+    #
+    # @return [Vault]
+    def &(o)
+        Vault::new(@roms.select {|rom| o.match(rom) })
+    end
+
+    
+    # Constuct a new ROM vault as the difference
+    #
+    # @param o [Vault]	ROM vault to substract to self
+    #
+    # @return [Vault]
+    def -(o)
+        Vault::new(@roms.reject {|rom| o.match(rom) })
+    end
+
+
+    # Add ROM
+    #
+    # @param [ROM] *roms	ROM to add
+    #
+    # @return self
+    #
+    def <<(rom)
+        add_rom(rom)
+    end
+
+    
+    # Add ROM
+    #
+    # @param [ROM] rom		ROM to add
+    #
+    # @return self
+    #
+    def add_rom(rom)
+        # Sanity check
+        unless ROM === rom
+            raise ArgumentError, "not a ROM" 
+        end
+
+        # Add it to the list
+        @roms << rom
+
+        # Keep track of checksums
+        @cksum.each {|type, hlist|
+            hlist.merge!(rom.cksum(type) => rom) {|key, old, new|
+                if Array(old).any? {|r| r.path == new.path}
+                then old
+                else Array(old) + [ new ]
+                end
+            }
+        }
+        
+        # Chainable
+        self
+    end
+
+    
+    # Add ROM from file
+    #
+    # @param file     [String] 		path to files relative to basedir
+    # @param basedir  [String,nil]	base directory
+    # @param archives [#include?]	archives tester
+    #
+    # @return [self]    
+    #
+    def add_from_file(file, basedir = nil, archives: ARCHIVES)
+        filepath = File.join(*[ basedir, file ].compact)
+        romlist  = if ROMArchive.archive?(filepath, archives: archives)
+                   then ROMArchive.from_file(filepath).to_a
+                   else ROM.from_file(file, basedir)
+                   end
+
+        Array(romlist).each {|rom| add_rom(rom) }
+    end
+
+    
+    # Add ROM from directory.
+    # @note file in {IGNORE_FILES}, directory in {IGNORE_DIRS}, 
+    #       directories holding a {DIR_PRUNING} file or starting with a
+    #       dot are ignored      
+    #
+    # @param dir       [String] 	path to directory
+    # @param depth     [Integer,nil]	exploration depth
+    # @param archives  [#include?]	archives tester
+    #
+    # @yieldparam file [String]		file being processed
+    # @yieldparam dir  [String]		directory relative to
+    #
+    # @return [self]
+    #
+    def add_from_dir(dir, depth: nil, archives: ARCHIVES)
+        Vault.from_dir(dir, depth: depth) do | file, dir: |
+            yield(file, dir: dir) if block_given?
+            add_from_file(file, dir, archives: archives)
+        end
+        self
+    end
+
+    
+    # Add ROM from glob
+    # @note file in {IGNORE_FILES}, directory in {IGNORE_DIRS}, 
+    #       directories holding a {DIR_PRUNING} file or starting with a
+    #       dot are ignored      
+    #
+    # @param glob     [String]		ruby glob
+    # @param basedir  [:guess,nil]	basedir to use when interpreting glob
+    #                                   matching
+    # @param archives [#include?]	archives tester
+    #
+    # @yieldparam file [String]		file being processed
+    # @yieldparam dir  [String]		directory relative to
+    #
+    # @return [self]
+    #
+    def add_from_glob(glob, basedir: :guess, archives: ARCHIVES)
+        Vault.from_dir(glob, basedir: basedir) do | file, dir: |
+            yield(file, dir: dir) if block_given?
+            add_from_file(file, dir, archives: archives)
+        end
+        self
+    end
+
+
+    # List of ROM with loosely defined (ie: with some missing checksum)
+    #
+    # @return [Array<ROM>,nil]
+    #
+    def with_partial_checksum
+        @roms.select {|rom| rom.missing_checksums? }
+    end
+
+
+    # Check if we have some headered ROM.
+    #
+    # @return [Integer]			only some ROMs are headered
+    # @return [true]			all ROMs are headered
+    # @return [false]			no headered ROM
+    #
+    def headered
+        size = @roms.select {|rom| rom.headered? }.size
+        
+        if    size == 0          then false
+        elsif size == @roms.size then true
+        else                          size
+        end
+    end
+    
+    # Return list of matching ROMs.
+    #
+    # @param query [Hash{Symbol=>String}]	Hash of checksums to match with
+    #
+    # @return [Array<ROM>]		list of matching ROMs
+    # @return [nil]			if no match
+    #
+    def cksummatch(query)
+        CHECKSUMS.each {|type|
+            if (q = query[type]) && (r = @cksum[type][q])
+                return Array(r)
+            end
+        }
+        return nil
+    end
+
+    # Return list of matching ROMs.
+    #
+    # @param rom [ROM]			ROM to match with
+    #
+    # @return [Array<ROM>]		list of matching ROMs
+    # @return [nil]			if no match
+    #
+    def rommatch(rom)
+        self.cksummatch(rom.cksums)
+    end
+
+    
+    # Return list of matching ROMs.
+    #
+    # @param query [Hash{Symbol=>String},ROM]	Hash of checksums or ROM
+    #                                           to match with
+    #
+    # @yieldparam rom [ROM]			ROM that has been saved
+    #
+    # @return [Array<ROM>]		list of matching ROMs
+    # @return [nil]			if no match
+    #
+    def match(query)
+        case query
+        when Hash then self.cksummatch(query)
+        when ROM  then self.rommatch(query)
+        else raise ArgumentError
+        end
+    end
+
+    
+    # Save ROM to filesystem
+    #
+    # @param dir      [String]		directory used for saving
+    # @param part   [:all,:header,:rom] wich part of the ROM file to save
+    # @param subdir   [Boolean,Integer,Proc] use subdirectory
+    # @param pristine [Boolean]		should existing directory be removed
+    # @param force    [Boolean]		remove previous file if necessary
+    #
+    # @yieldparam rom [ROM]		ROM saved
+    #
+    # @return [self]
+    #
+    def save(dir, part: :all, subdir: false, pristine: false, force: false,
+             &block)
+        # Directory
+        FileUtils.remove_dir(dir) if     pristine	 # Create clean env
+        Dir.mkdir(dir)            unless Dir.exist?(dir) # Ensure directory
+
+        # Fill directory.
+        # -> We have the physical ROMs, so we have all the checksums
+        #    except if the file is an header without rom content
+        @roms.select {|rom| rom.has_content? && !rom.fshash.nil? }
+             .each   {|rom|
+            hash    = rom.fshash
+            destdir = dir
+            dirpart = case subdir
+                      when nil, false then nil
+                      when true       then hash[0..3]
+                      when Integer    then hash[0..subdir]
+                      when Proc       then subdir.call(rom)
+                      else raise ArgumentError, "unsupported subdir type"
+                      end
+                          
+            if dirpart
+                # Update destination directory
+                destdir = File.join(destdir, *dirpart)
+                # Ensure destination directory exists
+                FileUtils.mkdir_p(destdir)
+            end
+
+            # Destination file
+            dest = File.join(destdir, hash)
+            
+            # If the file exist, it is the right file, as it is
+            # named from it's hash (ie: content)
+            if force || !File.exists?(dest)
+                rom.copy(dest, part: part, force: force)
+            end
+            
+            block.call(rom) if block
+        }
+        self
+    end
+
+
+    # Dumping of ROM vault entries
+    #
+    # @param compact [Boolean]
+    #
+    # @return [self]
+    #
+    # @yieldparam group   [String]
+    # @yieldparam entries [Array<String>]
+    #
+    def dump(compact: false, &block)
+        self.each.inject({}) {|grp, rom|
+            grp.merge(rom.path.storage => [rom]) {|key, old, new| old + new }
+        }.each {|storage, roms|
+            size = if ROM::Path::Archive === roms.first.path
+                       roms.first.path.archive.size
+                   end
+            
+            if storage.nil?
+                roms.each {|rom| block.call(rom.path.entry, nil) }
+            else
+                if compact && (size == roms.size)
+                then block.call(storage)
+                else block.call(storage, roms.map {|r| r.path.entry })
+                end
+            end
+        }
+        self
+    end
+    
+    protected
+
+    def roms
+        @roms
+    end
+end
+
+end

data/lib/distillery/version.rb

@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: EUPL-1.2
+
+module Distillery
+
+    VERSION = "0.1"
+
+end

metadata

@@ -0,0 +1,192 @@
+--- !ruby/object:Gem::Specification
+name: rom-distillery
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Stephane D'Alu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-05-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tty-screen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tty-logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tty-spinner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tty-progressbar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Help organise emulation ROM using DAT file
+email:
+- sdalu@sdalu.com
+executables:
+- rhum
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- README.md
+- bin/rhum
+- distillery.gemspec
+- lib/distillery.rb
+- lib/distillery/archiver.rb
+- lib/distillery/archiver/archive.rb
+- lib/distillery/archiver/external.rb
+- lib/distillery/archiver/external.yaml
+- lib/distillery/archiver/libarchive.rb
+- lib/distillery/archiver/zip.rb
+- lib/distillery/cli.rb
+- lib/distillery/cli/check.rb
+- lib/distillery/cli/clean.rb
+- lib/distillery/cli/header.rb
+- lib/distillery/cli/index.rb
+- lib/distillery/cli/overlap.rb
+- lib/distillery/cli/rebuild.rb
+- lib/distillery/cli/rename.rb
+- lib/distillery/cli/repack.rb
+- lib/distillery/cli/validate.rb
+- lib/distillery/datfile.rb
+- lib/distillery/error.rb
+- lib/distillery/game.rb
+- lib/distillery/game/release.rb
+- lib/distillery/refinements.rb
+- lib/distillery/rom-archive.rb
+- lib/distillery/rom.rb
+- lib/distillery/rom/path.rb
+- lib/distillery/rom/path/archive.rb
+- lib/distillery/rom/path/file.rb
+- lib/distillery/rom/path/virtual.rb
+- lib/distillery/storage.rb
+- lib/distillery/vault.rb
+- lib/distillery/version.rb
+homepage: http://github.com/sdalu/distillery
+licenses:
+- EUPL-1.2
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.6
+signing_key: 
+specification_version: 4
+summary: ROM manager
+test_files: []