rom-distillery 0.1

data/lib/distillery/cli.rb

@@ -0,0 +1,234 @@
+# SPDX-License-Identifier: EUPL-1.2
+
+require 'optparse'
+require 'json'
+require 'tty/screen'
+require 'tty/logger'
+require 'tty/spinner'
+require 'tty/spinner/multi'
+require 'tty/progressbar'
+
+require_relative 'storage'
+require_relative 'datfile'
+require_relative 'refinements'
+
+
+if !defined?(::Version)
+    Version = Distillery::VERSION 
+end
+
+
+module Distillery
+
+class CLI
+    using Distillery::StringY
+    
+    # List of available output mode
+    OUTPUT_MODE = [ :text, :fancy, :json ]
+
+    
+    # @!visibility private
+    @@subcommands = {}
+
+
+    # Execute the CLI
+    def self.run(argv = ARGV)
+        self.new.parse(argv)
+    end
+
+    
+    # Register a new (sub)command into the CLI
+    #
+    # @param name [Symbol]
+    # @param description [String]
+    # @param optpartser [OptionParser]
+    #
+    # @yieldparam argv [Array<String>]
+    # @yieldparam into: [Object]
+    # @yieldreturn Array<Object>	# Subcommand parameters
+    #
+    def self.subcommand(name, description, optparser=nil, &exec)
+        @@subcommands[name] = [ description, optparser, exec ]
+    end
+
+    
+    # Global option parser
+    #
+    GlobalParser = OptionParser.new do |opts|
+        opts.banner = "Usage: #{opts.program_name} [options] CMD [opts] [args]"
+
+        opts.separator ""
+        opts.separator "Options:"
+        opts.on "-h", "--help",         "Show this message" do
+            puts opts
+            puts ""
+            puts "Commands:"
+            @@subcommands.each {|name, (desc, *) |
+                puts "    %-12s %s" % [ name, desc ]
+            }
+            puts ""
+            puts "See '#{opts.program_name} CMD --help'"		\
+                 " for more information on a specific command"
+            puts ""
+            exit
+        end
+
+        opts.on "-V", "--version",      "Show version" do
+            puts opts.ver()
+            exit
+        end        
+
+        opts.separator ""
+        opts.separator "Global options:"
+        opts.on "-o", "--output=FILE",                   "Output file"
+        opts.on "-m", "--output-mode=MODE", OUTPUT_MODE,
+                "Output mode (#{OUTPUT_MODE.first})",
+                " Value: #{OUTPUT_MODE.join(', ')}"
+        opts.on "-d", "--dat=FILE",                      "DAT file"
+        opts.on "-I", "--index=FILE",                    "Index file"
+        opts.on "-D", "--destdir=DIR",                   "Destination directory"
+        opts.on "-f", "--force",                         "Force operation"
+        opts.on '-p', '--[no-]progress',                 "Show progress"
+        opts.on '-v', '--[no-]verbose',                  "Run verbosely"
+    end
+
+    
+    # Program name
+    PROGNAME = GlobalParser.program_name
+    
+    def initialize
+        @verbose     = true
+        @progress    = true
+        @output_mode = OUTPUT_MODE.first
+        @io          = $stdout
+    end
+
+
+    # Parse command line arguments
+    #
+    #
+    def parse(argv)
+        # Parsed option holder
+        opts = {}
+
+        # Parse global options
+        GlobalParser.order!(argv, into: opts)
+
+        # Check for subcommand
+        subcommand = argv.shift&.to_sym
+        if subcommand.nil?
+            warn "subcommand missing"
+            exit
+        end
+        if !@@subcommands.include?(subcommand)
+            warn "subcommand \'#{subcommand}\' is not recognised"
+            exit
+        end
+
+        # Process our options
+        if opts.include?(:output)
+            @io = File.open(opts[:output],
+                            File::CREAT|File::TRUNC|File::WRONLY)
+        end
+        if opts.include?(:verbose)
+            @verbose = opts[:verbose]
+        end
+        if opts.include?(:progress)
+            @progress = opts[:progress]
+        end
+        if opts.include?(:'output-mode')
+            @output_mode = opts[:'output-mode']
+        end
+
+        # Sanitize
+        if (@ouput_mode == :fancy) && !@io.tty?
+            @output_mode = :text
+        end
+
+        # Parse command, and build arguments call
+        _, optparser, argbuilder = @@subcommands[subcommand]
+        optparser.order!(argv, into: opts) if optparser
+        args = argbuilder.call(argv, **opts)
+
+        # Call subcommand
+        self.method(subcommand).call(*args)
+    rescue OptionParser::InvalidArgument => e
+        warn "#{PROGNAME}: #{e}"
+    end
+
+    
+    # Create DAT from file
+    #
+    # @param file	[String]	dat file
+    # @param verbose	[Boolean]	be verbose
+    #
+    # @return [DatFile]
+    #
+    def make_dat(file, verbose: @verbose, progress: @progress)
+        dat = DatFile.new(file)
+        if verbose
+            $stderr.puts "DAT = #{dat.version}"
+        end
+        dat
+    end
+
+
+
+    # Potential ROM from directory.
+    # @see Vault.from_dir for details
+    #
+    # @param romdirs   [Array<String>] 	path to rom directoris
+    # @param depth     [Integer,nil]	exploration depth
+    #
+    # @yieldparam file [String]		file being processed
+    # @yieldparam dir: [String]		directory relative to
+    #
+    def from_romdirs(romdirs, depth: nil, &block)
+        romdirs.each {|dir| 
+            Vault.from_dir(dir, depth: depth, &block)
+        }
+    end
+
+    
+    # Create Storage from ROMs directories
+    #
+    # @param romdirs	[Array<String>] array of ROMs directories
+    # @param verbose	[Boolean]	be verbose
+    #
+    # @return [Storage]
+    #
+    def make_storage(romdirs, depth: nil,
+                     verbose: @verbose, progress: @progress)
+        vault = Vault::new
+        block = ->(file, dir:) { vault.add_from_file(file, dir) }
+        
+        if progress
+            TTY::Spinner.new("[:spinner] :file", :hide_cursor => true,
+                                                 :clear       => true)
+                        .run('Done!') {|spinner|
+                from_romdirs(romdirs, depth: depth) {|file, dir:|
+                    width = TTY::Screen.width - 8
+                    spinner.update(:file => file.ellipsize(width, :middle))
+                    block.call(file, dir: dir)
+                }
+            }
+        else
+            from_romdirs(romdirs, depth: depth, &block)
+        end
+
+        Storage::new(vault)
+    end
+    
+end
+end
+
+
+require_relative 'cli/check'
+require_relative 'cli/validate'
+require_relative 'cli/index'
+require_relative 'cli/rename'
+require_relative 'cli/rebuild'
+require_relative 'cli/repack'
+require_relative 'cli/overlap'
+require_relative 'cli/header'
+require_relative 'cli/clean'

data/lib/distillery/cli/check.rb

@@ -0,0 +1,100 @@
+# SPDX-License-Identifier: EUPL-1.2
+
+module Distillery
+class CLI
+
+    # Check that the ROM directories form an exact match of the DAT file
+    #
+    # @param datfile  	[String]		DAT file
+    # @param romdirs 	[Array<String>]		ROMs directories
+    #
+    # @return [self]
+    #
+    def check(datfile, romdirs, revert: false)
+        dat      = make_dat(datfile)        
+        storage  = make_storage(romdirs)
+        
+        missing  = dat.roms - storage.roms
+        extra    = storage.roms - dat.roms
+        included = dat.roms & storage.roms
+        
+        printer  = proc {|entry, subentries|
+            @io.puts "- #{entry}"
+            Array(subentries).each {|entry| @io.puts "  . #{entry}" }
+        }
+
+        # Warn about presence of headered ROM
+        if storage.headered
+            warn "===> Headered ROM"
+        end
+    
+    
+        # Show included ROMs
+        if revert
+            if included.empty?
+                @io.puts "==> No rom included"
+            else
+                @io.puts "==> Included roms (#{included.size}):"
+                included.dump(comptact: true, &printer)
+            end
+
+        # Show mssing and extra ROMs
+        else
+            if ! missing.empty?
+                @io.puts "==> Missing roms (#{missing.size}):"
+                missing.dump(compact: true, &printer)
+            end
+            @io.puts if !missing.empty? && !extra.empty?
+            if ! extra.empty?
+                @io.puts "==> Extra roms (#{extra.size}):"
+                extra.dump(compact: true, &printer)
+            end
+            
+        end
+
+        # Have we a perfect match ?
+        if missing.empty? && extra.empty?
+            @io.puts "==> PERFECT"
+        end
+
+        self
+    end
+
+
+    # -----------------------------------------------------------------
+
+    
+    # Parser for check command
+    CheckParser = OptionParser.new do |opts|
+        opts.banner = "Usage: #{PROGNAME} check [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 check command
+    subcommand :check, "Check ROM status",
+               CheckParser 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], revert: opts[:revert] || false ]
+    end
+end
+
+end

data/lib/distillery/cli/clean.rb

@@ -0,0 +1,60 @@
+# SPDX-License-Identifier: EUPL-1.2
+
+module Distillery
+
+class CLI
+
+    def clean(datfile, romdirs, savedir: nil)
+        dat        = make_dat(datfile)        
+        storage    = make_storage(romdirs)
+        extra      = storage.roms - dat.roms
+
+        extra.save(savedir) if savedir
+        extra.each {|rom| rom.delete! }
+    end
+    
+
+    # -----------------------------------------------------------------
+    
+    # Parser for clean command
+    CleanParser = OptionParser.new do |opts|
+        opts.banner = "Usage: #{PROGNAME} clean [options] ROMDIR..."
+
+        opts.separator ""
+        opts.separator "Remove content not referenced in DAT file"
+        opts.separator ""
+        opts.separator "Options:"
+        opts.on '-s', '--summarize', "Summarize results"
+        opts.separator ""
+
+    end
+
+    # Register clean command
+    subcommand :clean, "Remove content not referenced in DAT file",
+               CleanParser 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[:savedir].nil? && (opts[:romdirs].size == 1)
+            opts[:savedir] = File.join(opts[:romdirs].first, '.trash')
+        end
+        
+        if opts[:dat].nil?
+            warn "missing datfile"
+            exit
+        end
+        if opts[:romdirs].empty?
+            warn "missing ROM directory"
+            exit
+        end
+        if opts[:savedir].empty?
+            warn "missing save directory"
+            exit
+        end
+        
+        [ opts[:dat], opts[:romdirs], savedir: opts[:savedir] ]
+    end
+end
+
+end

data/lib/distillery/cli/header.rb

@@ -0,0 +1,61 @@
+# SPDX-License-Identifier: EUPL-1.2
+
+module Distillery
+class CLI
+
+    # Save ROM header in a specified directory
+    #
+    # @param hdrdir  	[String]		Directory for saving headers
+    # @param romdirs 	[Array<String>]		ROMs directories
+    #
+    # @return [self]
+    #
+    def header(hdrdir, romdirs)
+        storage = make_storage(romdirs)
+        storage.roms.select {|rom| rom.headered? }.each {|rom|
+            file   = File.join(hdrdir, rom.fshash)
+            header = rom.header
+            if File.exists?(file)
+                if header != File.binread(file)
+                    warn "different header exists : #{rom.fshash}"
+                end
+                next
+            end
+            File.write(file, header)
+        }
+
+        self
+    end
+
+
+    # -----------------------------------------------------------------
+
+    
+    # Parser for header command
+    HeaderParser = OptionParser.new do |opts|
+        opts.banner = "Usage: #{PROGNAME} index ROMDIR..."
+
+        opts.separator ""
+        opts.separator "Extract ROM embedded header"
+        opts.separator ""
+        opts.separator "Options:"
+        opts.separator ""
+    end
+
+    
+    # Register header command
+    subcommand :header, "Extract ROM embedded header",
+               HeaderParser do |argv, **opts|
+        opts[:romdirs] = ARGV
+        if opts[:destdir].nil? && (opts[:romdirs].size == 1)
+            opts[:destdir] = File.join(opts[:romdirs].first, '.header')
+        end
+        if opts[:romdirs].empty?
+            warn "missing ROM directory"
+            exit
+        end
+
+        [ opts[:destdir], opts[:romdirs] ]
+    end
+end
+end