rom-distillery 0.1

data/lib/distillery/cli/index.rb

@@ -0,0 +1,65 @@
+# SPDX-License-Identifier: EUPL-1.2
+
+module Distillery
+class CLI
+
+    # Print index (hash and path of each ROM)
+    #
+    # @param romdirs 	[Array<String>]		ROMs directories
+    # @param type	[Symbol,nil]		type of checksum to use
+    #
+    # @return [self]
+    #
+    def index(romdirs, type: nil, separator: nil)
+        list = make_storage(romdirs).index(type, separator)
+
+        if (@output_mode == :fancy) || (@output_mode == :text)
+            list.each {|hash, path|
+                @io.puts "#{hash} #{path}"
+            }
+
+        elsif @output_mode == :json
+            @io.puts Hash[list.each.to_a].to_json
+            
+        else
+            raise Assert
+        end
+            
+        self
+    end    
+
+
+    # -----------------------------------------------------------------
+
+    
+    # Parser for index command
+    IndexParser = OptionParser.new do |opts|
+        opts.banner = "Usage: #{PROGNAME} index [options] ROMDIR..."
+
+        opts.separator ""
+        opts.separator "Generate hash index"
+        opts.separator ""
+        opts.separator "Options:"
+        opts.on '-c', '--cksum=CHECKSUM', ROM::CHECKSUMS,
+                "Checksum used for indexing (#{ROM::FS_CHECKSUM})",
+                " Value: #{ROM::CHECKSUMS.join(', ')}"
+        opts.on '-s', '--separator=CHAR', String,
+                "Separator for archive entry (#{ROM::Path::Archive.separator})"
+        opts.separator ""
+    end
+
+    
+    # Register index command
+    subcommand :index, "Generate hash index",
+               IndexParser do |argv, **opts|
+
+        if argv.empty?
+            warn "At least one rom directory is required"
+            exit
+        end
+
+        [ argv, type: opts[:cksum], separator: opts[:separator] ]
+    end
+    
+end
+end

data/lib/distillery/cli/overlap.rb

@@ -0,0 +1,39 @@
+# SPDX-License-Identifier: EUPL-1.2
+
+module Distillery
+class CLI
+
+    def overlap(index, romdirs)
+        index   = Hash[File.readlines(index).map {|line| line.split(' ', 2) }]
+        storage = make_storage(romdirs)
+        storage.roms.select {|rom| index.include?(rom.sha1) }
+            .each {|rom|
+            @io.puts rom.path
+        }
+        
+    end
+
+
+    # -----------------------------------------------------------------
+
+    # Parser for overlap command
+    OverlapParser = OptionParser.new do |opts|
+        opts.banner = "Usage: #{PROGNAME} overlap [options] ROMDIR..."
+
+        opts.separator ""
+        opts.separator "Check ROMs status, and display missing or extra files."
+        opts.separator ""
+        opts.separator "Options:"
+        opts.on '-r', '--revert', "Display present files instead"
+        opts.separator ""
+    end
+
+    
+    # Register overlap command
+    subcommand :overlap, "Check for overlaping ROM" do |argv, **opts|
+        opts[:romdirs] = argv
+        
+        [ opts[:index], opts[:romdirs] ]
+    end
+end
+end

data/lib/distillery/cli/rebuild.rb

@@ -0,0 +1,47 @@
+# SPDX-License-Identifier: EUPL-1.2
+
+module Distillery
+class CLI
+
+    def rebuild(gamedir, datfile, romdirs)
+        dat     = make_dat(datfile)
+        storage = make_storage(*romdirs)
+
+        # gamedir can be one of the romdir we must find a clever
+        # way to avoid overwriting file
+        
+        romsdir = File.join(gamedir, '.roms')
+        storage.build_roms_directory(romsdir, delete: true)
+
+        vault = ROMVault.new
+        vault.add_from_dir(romsdir)
+        
+        storage.build_games_archives(gamedir, dat, vault, '7z')
+        FileUtils.remove_dir(romsdir)
+    end
+
+    # -----------------------------------------------------------------
+
+    
+    # Parser for header command
+    RebuildParser = OptionParser.new do |opts|
+        opts.banner = "Usage: #{PROGNAME} rebuild ROMDIR..."
+    end
+
+    
+    # Register rebuild command
+    subcommand :rebuild, "Rebuild according to DAT file",
+               RebuildParser do |argv, **opts|
+        opts[:romdirs] = argv
+        if opts[:dat].nil? && (opts[:romdirs].size >= 1)
+            opts[:dat] = File.join(opts[:romdirs].first, '.dat')
+        end
+        
+        if opts[:destdir].nil? && (opts[:romdirs].size >= 1)
+            opts[:destdir] = opts[:romdirs].first
+        end
+        
+        [ opts[:destdir], opts[:dat], opts[:romdirs] ]
+    end        
+end
+end

data/lib/distillery/cli/rename.rb

@@ -0,0 +1,34 @@
+# SPDX-License-Identifier: EUPL-1.2
+
+module Distillery
+class CLI
+
+    def rename(datfile, romdirs)
+        dat     = Distillery::DatFile.new(datfile)
+        storage = create_storage(romdirs)
+        
+        storage.rename(dat)
+    end
+
+    # -----------------------------------------------------------------
+
+    
+    # Register rename command
+    subcommand :rename, "Rename ROMs according to DAT" do |argv, **opts|
+        opts[:romdirs] = argv
+        if opts[:dat].nil? && (opts[:romdirs].size == 1)
+        opts[:dat] = File.join(opts[:romdirs].first, '.dat')
+        end
+        if opts[:dat].nil?
+            warn "missing datfile"
+            exit
+        end
+        if opts[:romdirs].empty?
+            warn "missing ROM directory"
+            exit
+        end
+        
+        [ opts[:dat], opts[:romdirs] ]
+    end
+end
+end

data/lib/distillery/cli/repack.rb

@@ -0,0 +1,113 @@
+# coding: utf-8
+# SPDX-License-Identifier: EUPL-1.2
+
+require 'securerandom'
+
+module Distillery
+class CLI
+    using Distillery::StringY
+
+    def repack(romdirs, type = nil)
+        type    ||= ROMArchive::PREFERED
+
+        decorator =
+            if @output_mode == :fancy
+                lambda {|file, type, &block|
+                    spinner = TTY::Spinner.new("[:spinner] :file",
+                                               :hide_cursor => true,
+                                               :output      => @io)
+                    width = TTY::Screen.width - 8
+                    spinner.update(:file => file.ellipsize(width, :middle))
+                    spinner.auto_spin
+                    case v = block.call
+                    when String then spinner.error("(#{v})")
+                    else             spinner.success("-> #{type}")
+                    end
+                }
+
+            elsif @output_mode == :text
+                lambda {|file, type, &block|
+                    case v = block.call
+                    when String
+                        @io.puts "FAILED: #{file} (#{v})"
+                        @io.puts "OK    : #{file} -> #{type}" if @verbose
+                    end
+                }
+                
+            else
+
+                raise Assert
+            end
+        
+        
+        from_romdirs(romdirs) { | srcfile, dir: |
+            # Destination file according to archive type
+            dstfile  = srcfile.dup
+            dstfile += ".#{type}" unless dstfile.sub!(/\.[^.\/]*$/, ".#{type}")
+
+            # Path for src and dst
+            src      = File.join(dir, srcfile)
+            dst      = File.join(dir, dstfile)
+
+            # If source and destination are the same
+            #  - move source out of the way as we could recompress
+            #    using another algorithm
+            if srcfile == dstfile
+                phyfile = srcfile + '.' + SecureRandom.alphanumeric(10)
+                phy     = File.join(dir, phyfile)
+                File.rename(src, phy)
+            else
+                phyfile = srcfile
+                phy     = src
+            end
+
+            # Recompress
+            decorator.(srcfile, type) { 
+                next "#{type} exists" if File.exists?(dst)
+                archive = Distillery::Archiver.for(dst)
+                Distillery::Archiver.for(phy).each {|entry, i|
+                    archive.writer(entry) {|o|
+                        while data = i.read(32 * 1024)
+                            o.write(data)
+                        end
+                    }
+                }
+                File.unlink(phy)
+            }
+        }
+    end
+
+    
+    # -----------------------------------------------------------------
+
+
+    # Parser for repack command
+    RepackParser = OptionParser.new do |opts|
+        types = ROMArchive::EXTENSIONS.to_a
+        opts.banner = "Usage: #{PROGNAME} repack [options] ROMDIR..."
+
+        opts.separator ""
+        opts.separator "Repack archives to the specified format"
+        opts.separator ""
+        opts.separator "NOTE: if an archive in the new format already exists the operation"
+        
+        opts.separator "      won't be carried out" 
+        opts.separator ""
+        opts.separator "Options:"
+        opts.on '-F', '--format=FORMAT', types,
+                "Archive format (#{ROMArchive::PREFERED})",
+                " Value: #{types.join(', ')}"
+        opts.separator ""
+    end
+
+    
+    # Register repack command
+    subcommand :repack, "Recompress archives",
+               RepackParser do |argv, **opts|
+        opts[:romdirs] = argv
+        
+        [ opts[:romdirs], opts[:format] ]
+    end
+    
+end
+end

data/lib/distillery/cli/validate.rb

@@ -0,0 +1,171 @@
+# SPDX-License-Identifier: EUPL-1.2
+
+module Distillery
+class CLI
+    using Distillery::StringY
+
+    # Validate ROMs according to DAT/Index file.
+    #
+    # @param romdirs 	[Array<String>]		ROMs directories
+    # @param datfile  	[String]		DAT file
+    #
+    # @return [self]
+    #
+    def validate(romdirs, datfile: nil, summarize: false)
+        dat        = make_dat(datfile)        
+        storage    = make_storage(romdirs)
+        count      = { :not_found     => 0,
+                       :name_mismatch => 0,
+                       :wrong_place   => 0 }
+        summarizer = lambda {|io|
+            io.puts
+            io.puts "Not found     : #{count[:not_found    ]}"
+            io.puts "Name mismatch : #{count[:name_mismatch]}"
+            io.puts "Wrong place   : #{count[:wrong_place  ]}"
+        }
+        checker    = lambda {|game, rom|
+            m = storage.roms.match(rom)
+                
+            if m.nil? || m.empty?
+                count[:not_found] += 1
+                "not found"
+            elsif (m = m.select {|r| r.name == rom.name }).empty?
+                count[:name_mismatch] += 1
+                "name mismatch"
+            elsif (m = m.select {|r|
+                       store = File.basename(r.path.storage)
+                       ROMArchive::EXTENSIONS.any? {|ext|
+                           ext = Regexp.escape(ext)
+                           store.gsub(/\.#{ext}$/i, '') == game.name
+                       } || (store == game.name) || romdirs.include?(store)
+                   }).empty?
+                count[:wrong_place] += 1
+                "wrong place"
+            end
+        }
+
+        
+
+        if @output_mode == :fancy
+            dat.each_game {|game|
+                s_width    = TTY::Screen.width
+                r_width    = s_width - 25
+                g_width    = s_width - 10
+                
+                game_name = game.name.ellipsize(g_width, :middle)
+                gspinner = TTY::Spinner::Multi.new("[:spinner] #{game_name}",
+                                                   :hide_cursor => true,
+                                                   :output      => @io)
+                
+                game.each_rom {|rom|
+                    rom_name = rom.name.ellipsize(r_width, :middle)
+                    rspinner = gspinner.register "[:spinner] :rom"
+                    rspinner.update(:rom => rom_name)
+                    rspinner.auto_spin
+                    
+                    case v = checker.(game, rom)
+                    when String then rspinner.error("-> #{v}")
+                    when nil    then rspinner.success
+                    else raise Assert
+                    end
+                }
+            }
+            if summarize
+                summarize.(@io)
+            end
+
+            
+        elsif (@output_mode == :text) && @verbose
+            dat.each_game {|game|
+                @io.puts "#{game}:"
+                game.each_rom {|rom|
+                    case v = checker.(game, rom)
+                    when String then @io.puts " - FAILED: #{rom} -> #{v}"
+                    when nil    then @io.puts " - OK    : #{rom}"
+                    else raise Assert
+                    end
+                }
+            }
+            if summarize
+                summarize.(@io)
+            end
+            
+        elsif @output_mode == :text
+            dat.each_game.flat_map {|game|
+                game.each_rom.map {|rom|
+                    case v = checker.(game, rom)
+                    when String then [ game.name, rom, v ]
+                    when nil
+                    else raise Assert
+                    end
+                }.compact
+            }.compact.group_by {|game,| game }.each {|game, list|
+                @io.puts "#{game}"
+                list.each {|_, rom, err|
+                    @io.puts " - FAILED: #{rom} -> #{err}"
+                }
+            }
+
+        elsif @output_mode == :json
+            @io.puts dat.each_game.map {|game|
+                { :game => game.name,
+                  :roms => game.each_rom.map {|rom|
+                      case v = checker.(game, rom)
+                      when String, nil then [ game.name, rom, v ]
+                      else raise Assert
+                      end
+                      { :rom     => rom.path.entry,
+                        :success => v.nil?,
+                        :reason  => v
+                      }.compact
+                  }
+                }
+            }.to_json
+        else
+            
+            raise Assert
+        end
+        
+        self
+    end
+
+
+    # -----------------------------------------------------------------
+
+    
+    # Parser for validate command
+    ValidateParser = OptionParser.new do |opts|
+        opts.banner = "Usage: #{PROGNAME} validate [options] ROMDIR..."
+
+        opts.separator ""
+        opts.separator "Validate ROMs according to DAT file"
+        opts.separator ""
+        opts.separator "Options:"
+        opts.on '-s', '--summarize', "Summarize results"
+        opts.separator ""
+
+    end
+
+    
+    # Register validate command
+    subcommand :validate, "Validate ROMs according to DAT file",
+               ValidateParser do |argv, **opts|
+        opts[:romdirs] = argv
+        
+        if opts[:dat].nil? && (opts[:romdirs].size >= 1)
+            opts[:dat] = File.join(opts[:romdirs].first, '.dat')
+        end
+        if opts[:dat].nil?
+            warn "missing datfile"
+            exit
+        end
+        if opts[:romdirs].empty?
+            warn "missing ROM directory"
+            exit
+        end
+        
+        [ opts[:romdirs], datfile: opts[:dat] ]
+    end
+end
+
+end