mm_tool 0.1.1

data/lib/mm_tool/mm_tool_cli.rb

@@ -0,0 +1,322 @@
+module MmTool
+
+  #=============================================================================
+  # Implement the command line interface for MmTool::ApplicationMain
+  #=============================================================================
+  class MmToolCli
+
+    require 'tty-command'
+    require 'tty-which'
+
+    #------------------------------------------------------------
+    # Initialize
+    #------------------------------------------------------------
+    def initialize(app_instance = MmTool::ApplicationMain.shared_application)
+      @application = app_instance
+      @defaults = MmUserDefaults.shared_user_defaults
+      @defaults.register_defaults(with_hash: USER_DEFAULTS)
+    end
+
+    #------------------------------------------------------------
+    # Print Help
+    #------------------------------------------------------------
+    #noinspection RubyResolve
+    def print_help
+      # Amount of hanging indent is dependent on the space arguments take up.
+      hang = @defaults.example_args_by_length[-1].length + 4
+
+      header = <<~HEREDOC
+        #{C.bold('Usage:')} #{File.basename($0)} [options...] <directory|file> [options...] <directory|file> ...
+        
+        Performs media analysis and reports on files that don't meet quality requirements and/or files that
+        have containers and/or streams of undesired types. Files with undesired containers and/or streams
+        can optionally be transcoded into a new file.
+        
+        You must specify a file or a directory. Specifying a directory implies a recursive search for files
+        matching the #{C.bold('--container-extension')} option.
+  
+        Options and files are processed as they occur, and remain in effect for subsequent input files until
+        encountered again with a different value. Boolean flags shown below modify default behavior. They
+        can be undone for subsequent input files with the capitalized version of the short flag, or by adding
+        or deleting #{C.bold('no-')} for the verbose argument form.
+
+        You can also set default options in #{PATH_USER_DEFAULTS}.
+      HEREDOC
+
+      puts OutputHelper.hanging_string(string: header, hang: 3, margin: OutputHelper.console_width)
+
+      @defaults.arguments_help_by_group.each_pair do |group, arguments|
+        puts group
+        arguments.each do |argument|
+          puts OutputHelper.hanging_string(string: argument, hang: hang, margin: OutputHelper.console_width) + "\n"
+        end
+      end
+    end
+
+    #------------------------------------------------------------
+    # Validate pre-requisites.
+    #------------------------------------------------------------
+    #noinspection RubyResolve
+    def validate_prerequisites
+      commands = %w(ffmpeg)
+      codecs   = %w(libx264 libx265 libfdk_aac)
+      task     = TTY::Command.new(printer: :null)
+      success  = true
+
+      # We'll check everything in items before failing, so that we can provide
+      # a comprehensive list to the user. No one wants to see what's missing
+      # on-by-one.
+      commands.each do |command|
+        unless TTY::Which.exist?(command)
+          OutputHelper.print_error("Error: #{C.bold(command)} is not installed (or not in your #{C.bold('$PATH')}).")
+          success = false
+        end
+      end
+      exit 1 unless success
+
+      # Now we'll make sure that all of the codecs that we're interested in
+      # are installed as part of ffmpeg. This is necessary because not every
+      # binary distribution supports non-free.
+
+      # Again, we'll check them all before failing in order to list everything.
+      codecs.each do |codec|
+        result = task.run!("ffprobe -v quiet -codecs | grep #{codec}")
+        OutputHelper.print_error("Error: ffmpeg was built without support for the #{C.bold(codec)} codec, which is required.") if result.failure?
+        success = success && result.success?
+      end
+      exit 1 unless success
+    end
+
+    #------------------------------------------------------------
+    # Run the CLI.
+    #------------------------------------------------------------
+    #noinspection RubyResolve
+    def run(args)
+
+      path = nil
+      while args.count > 0 do
+
+        # Convert single hyphen arguments to one or more multi-hyphen
+        # arguments. Doing this as an extra step eliminates redundancy,
+        # but also allows -abc in place of -a -b -c.
+        if args[0] =~ /^-[A-Za-z]+$/
+
+          args[0][1..-1].reverse.each_char do |char|
+
+            case char
+
+            when 'h'
+              args.insert(1, "--help")
+            when 'i'
+              args.insert(1, "--no-info-header")
+            when 'I'
+              args.insert(1, '--info-header')
+            when 't'
+              args.insert(1, "--transcode")
+            when 'T'
+              args.insert(1, "--no-transcode")
+            when 'u'
+              args.insert(1, "--no-fix-undefined-language")
+            when 'U'
+              args.insert(1, "--fix-undefined-language")
+            when 'p'
+              args.insert(1, "--dump")
+            when 'P'
+              args.insert(1, "--no-dump")
+            else
+              OutputHelper.print_error_and_exit("Error: option #{C.bold(args[0])} was specified, but I don't know what that means.")
+            end
+
+          end
+
+          args.shift
+          next
+        end
+
+        # The main loop processes options, commands, and files in first-in,
+        # first out order, which is the normal Unix way compared to how
+        # Ruby scripts try to handle things.
+        case args[0]
+
+          #-----------------------
+          # Main Options
+          #-----------------------
+
+        when '--help'
+          self.print_help
+          exit 0
+
+        when '--containers'
+          @defaults[:container_files] = validate_arg_value(args[0], args[1]).split(',')
+          args.shift
+
+        when '--scan'
+          value = validate_arg_value(args[0], args[1]).downcase
+          unless %w(normal all flagged quality force).include?(value)
+            OutputHelper.print_error("Note: value #{C.bold(value)} doesn't make sense; assuming #{C.bold('normal')}.")
+            value = 'normal'
+          end
+          @defaults[:scan_type] = value
+          args.shift
+
+        when '--ignore-titles'
+          @defaults[:ignore_titles] = true
+
+        when '--no-ignore-titles'
+          @defaults[:ignore_titles] = false
+
+        when '--no-info-header'
+          @defaults[:info_header] = false
+
+        when '--info-header'
+          @defaults[:info_header] = true
+
+        when '--version'
+          puts "#{File.basename $0}, version #{MmTool::VERSION}"
+
+        when '--'
+          break
+
+          #-----------------------
+          # Command-like Options
+          #-----------------------
+
+        when '--transcode'
+          @defaults[:ignore_files] = false
+          @defaults[:unignore_files] = false
+          @defaults[:transcode] = true
+
+        when '--no-transcode'
+          @defaults[:transcode] = false
+          @defaults.tempfile = nil
+
+        when '--ignore-files'
+          @defaults[:ignore_files] = true
+
+        when '--no-ignore-files'
+          @defaults[:ignore_files] = false
+
+        when '--unignore-files'
+          @defaults[:unignore_files] = true
+
+        when '--no-unignore-files'
+          @defaults[:unignore_files] = false
+
+
+          #-----------------------
+          # Media
+          #-----------------------
+
+        when '--containers-preferred'
+          @defaults[:containers_preferred] = validate_arg_value(args[0], args[1]).split(',')
+          args.shift
+
+        when '--codecs-audio-preferred'
+          @defaults[:codec_audio_preferred] = validate_arg_value(args[0], args[1]).split(',')
+          args.shift
+
+        when '--codecs-video-preferred'
+          @defaults[:codec_video_preferred] = validate_arg_value(args[0], args[1]).split(',')
+          args.shift
+
+        when '--codecs-subs-preferred'
+          @defaults[:codec_subs_preferred] = validate_arg_value(args[0], args[1]).split(',')
+          args.shift
+
+        when '--keep-langs-audio'
+          @defaults[:keep_langs_audio] = validate_arg_value(args[0], args[1]).split(',')
+          args.shift
+
+        when '--keep_langs_video'
+          @defaults[:keep_langs_video] = validate_arg_value(args[0], args[1]).split(',')
+          args.shift
+
+        when '--keep-langs-subs'
+          @defaults[:keep_langs_subs] = validate_arg_value(args[0], args[1]).split(',')
+          args.shift
+
+        when '--no-use-external-subs'
+          @defaults[:use_external_subs] = false
+
+        when '--use-external-subs'
+          @defaults[:use_external_subs] = true
+
+          #-----------------------
+          # Transcoding
+          #-----------------------
+
+        when '--no-drop-subs'
+          @defaults[:drop_subs] = false
+
+        when '--suffix'
+          @defaults[:suffix] = validate_arg_value(args[0], args[1])
+
+        when '--undefined-language'
+          @defaults[:suffix] = validate_arg_value(args[0], args[1])
+
+        when '--no-fix-undefined-language'
+          @defaults[:fix_undefined_language] = false
+
+        when '--fix-undefined-language'
+          @defaults[:fix_undefined_language] = true
+
+          #-----------------------
+          # Quality
+          #-----------------------
+
+        when '--min-width'
+          @defaults[:min_width] = validate_arg_value(args[0], args[1])
+
+        when '--min-channels'
+          @defaults[:min_channels] = validate_arg_value(args[0], args[1])
+
+          #-----------------------
+          # Other
+          #-----------------------
+
+        else
+
+          # An unknown parameter was encountered, so let's stop everything.
+          if args[0] =~ /^--.*$/
+            OutputHelper.print_error_and_exit("Error: option #{C.bold(args[0])} was specified, but I don't know what that means.")
+          end
+
+          # Otherwise, check for existence of the path, and warn or proceed.
+          path = File.expand_path(args[0])
+          if File.exist?(path)
+            @application.run(path)
+          else
+            OutputHelper.print_error("Note: skipping #{C.bold(path)}, which seems not to exist.")
+          end
+
+        end # case
+
+        args.shift
+
+      end # while
+
+      # If path has never been set, then the user didn't specify anything to check,
+      # which is likely to be a mistake.
+      unless path
+        OutputHelper.print_error_and_exit("You did not specify any input file(s) or directory(s). Use #{C.bold(File.basename($0))} for help.")
+      end
+
+    end
+
+    #------------------------------------------------------------
+    # Perform a really simple validation of the given value for
+    # the given argument, returning the value if successful.
+    # ------------------------------------------------------------
+    #noinspection RubyResolve
+    def validate_arg_value(arg, value)
+      if !value
+        OutputHelper.print_error_and_exit("Error: option #{C.bold(arg)} was specified, but no value was given.")
+      elsif value =~ /^-.*$/
+        OutputHelper.print_error_and_exit("Error: option #{C.bold(arg)} was specified, but the value #{C.bold(value)} looks like another option argument.")
+      end
+      value
+    end
+
+  end # class
+
+end # module

data/lib/mm_tool/mm_user_defaults.rb

@@ -0,0 +1,290 @@
+module MmTool
+
+  #=============================================================================
+  # A single user default.
+  #=============================================================================
+  class MmUserDefault
+
+    #------------------------------------------------------------
+    # Attributes
+    #------------------------------------------------------------
+    attr_reader :name
+    attr_reader :default
+    attr_reader :arg_short
+    attr_reader :arg_long
+    attr_reader :arg_format
+    attr_reader :item_label
+    attr_reader :help_group
+    attr_reader :help_desc
+
+    #------------------------------------------------------------
+    # Initialize
+    #------------------------------------------------------------
+    def initialize(key:, value:)
+      @name       = key
+      @value      = value[:value]
+      @default    = value[:default]
+      @arg_short  = value[:arg_short]
+      @arg_long   = value[:arg_long]
+      @arg_format = value[:arg_format]
+      @item_label = value[:item_label]
+      @help_group = value[:help_group]
+      @help_desc  = value[:help_desc]
+      @value_set = false
+    end
+
+    #------------------------------------------------------------
+    # Value attribute accessors.
+    #------------------------------------------------------------
+    def value
+      if value_set?
+        @value
+      else
+        @default
+      end
+    end
+
+    def value=(value)
+      @value = value
+      @value_set = true
+    end
+
+    def value_printable
+      if self.value.instance_of?(Array)
+        self.value.join(',')
+      elsif [TrueClass, FalseClass].include?(self.value.class)
+        self.value.human
+      else
+        self.value
+      end
+    end
+
+    #------------------------------------------------------------
+    # Indicates whether or not a value has been set.
+    #------------------------------------------------------------
+    def value_set?
+      @value_set
+    end
+
+    #------------------------------------------------------------
+    # Utility: get an argument for output, aligning the short
+    #  and long forms.
+    #------------------------------------------------------------
+    def example_arg
+      s = self.arg_short ? "#{self.arg_short}," : nil
+      l = self.arg_format ? "#{self.arg_long} #{self.arg_format}" : "#{self.arg_long}"
+      # " %-3s %s   " % [s, l]
+      "%-3s %s" % [s, l]
+    end
+
+  end # class
+
+
+  #=============================================================================
+  # Handles application user defaults as a singleton. This is specific to
+  # MmTool, and is not meant to be a general purpose User Defaults system.
+  #=============================================================================
+  class MmUserDefaults
+
+    require 'tty-table'
+
+    #------------------------------------------------------------
+    # Singleton accessor.
+    #------------------------------------------------------------
+    def self.shared_user_defaults
+      unless @self
+        @self = self.new
+      end
+      @self
+    end
+
+    #------------------------------------------------------------
+    # Initialize
+    #------------------------------------------------------------
+    def initialize
+      @defaults = {}
+    end
+
+    #------------------------------------------------------------
+    # The location on the filesystem where the file exists.
+    #------------------------------------------------------------
+    def file_path
+      PATH_USER_DEFAULTS
+    end
+
+
+    #------------------------------------------------------------
+    # Creates a new user default object and add it to the
+    # collection.
+    #------------------------------------------------------------
+    def define_default(for_key:, value:)
+      @defaults[for_key] = MmUserDefault.new(key:for_key,value:value)
+    end
+
+    #------------------------------------------------------------
+    # Sets up initial defaults from a large hash indicating all
+    # of the user defaults and attributes for the default.
+    # Also sets up the persistence system. If the file doesn't
+    # exist, it will be created with the current key-value
+    # pairs. If it does exist, existing key-value pairs will
+    # be reconciled with current key-value pairs. Finally,
+    # values from the file will be applied.
+    #------------------------------------------------------------
+    def register_defaults(with_hash:)
+
+      # *Define* each of the possible defaults. These will have
+      # default values. We're actually kind of good to go at
+      # this point if we don't want to use the rc file.
+
+      with_hash.each {|k,v| define_default(for_key:k, value:v) }
+
+      # If the file doesn't exist, create it and add our current
+      # key-value pairs to it. Otherwise, read the file, compare
+      # it to our current set of key-value pairs, and make
+      # adjustments, re-writing the file if necessary.
+
+      if !File.file?(file_path)
+        FileUtils.mkdir_p(File.dirname(file_path))
+        File.open(file_path, 'w') { |file| file.write(hash_representation.to_yaml) }
+      else
+        #noinspection RubyResolve
+        #@type [Hash] working
+        working = YAML.load(File.read(file_path))
+        new = working.select {|k,_| hash_representation.has_key?(k)} # only keeps working items if they are current.
+        new = new.merge(hash_representation.select {|k,_| !new.has_key?(k)}) # select the new items.
+        File.open(file_path, 'w') { |file| file.write(new.to_yaml) } unless working == new
+        new.each {|k,v| self[k] = v }
+      end
+    end
+
+    #------------------------------------------------------------
+    # Returns all default instances as an array.
+    #------------------------------------------------------------
+    def all_defaults
+      @defaults.values.sort_by(&:name)
+    end
+
+    #------------------------------------------------------------
+    # Returns all default instances as a hash, with key and
+    # value only. If there's no item label, assume that the
+    # default is a command and not an actual setting, and
+    # skip it.
+    #------------------------------------------------------------
+    def hash_representation
+      all_defaults.select {|d| d.item_label}
+          .collect { |d| [d.name, d.value] }.to_h
+    end
+
+    #------------------------------------------------------------
+    # Get a single default instance.
+    #------------------------------------------------------------
+    def default(key)
+      @defaults[key]
+    end
+
+    #------------------------------------------------------------
+    # Return the value of a setting by key or nil.
+    #------------------------------------------------------------
+    def [](key)
+      result = default(key)
+      result ? result.value : nil
+    end
+
+    #------------------------------------------------------------
+    # Set the value of a setting by key.
+    #------------------------------------------------------------
+    def []=(key, value)
+      if default(key)
+        default(key).value = value
+      else
+        define_default(for_key:key, value:value)
+      end
+    end
+
+    #------------------------------------------------------------
+    # Get and set defaults via methods.
+    #------------------------------------------------------------
+    def method_missing(method, *args)
+      if defines_default?(method) && args.empty?
+        self[method]
+      elsif method.to_s =~ /^(\w+)=$/ && args.size == 1
+        self[Regexp.last_match(1).to_sym] = args[0]
+      else
+        super
+      end
+    end
+
+    #------------------------------------------------------------
+    # Ensure that we account for our dynamic methods.
+    #------------------------------------------------------------
+    def respond_to?(method, include_private = false)
+      super || defines_default?(method) || (method =~ /^(\w+)=$/ && defines_default?(Regexp.last_match(1)))
+    end
+
+    #------------------------------------------------------------
+    # Does the default exist?
+    #------------------------------------------------------------
+    def defines_default?(key)
+      @defaults.key?(key)
+    end
+
+    #------------------------------------------------------------
+    # Utility: get all of the argument help text by group, into
+    #   a simple hash with group names as keys.
+    #------------------------------------------------------------
+    def arguments_help_by_group
+
+      table = {}
+
+      argument_groups.each do |group|
+
+        #noinspection RubyResolve
+        key = "\n#{C.bold(group)}\n\n"
+        table[key] = []
+
+        @defaults.values.select { |default| default.help_group == group }
+            .each do |default|
+          width = example_args_by_length[-1].length
+          arg = " %-#{width}.#{width}s   " % default.example_arg
+          des = default.help_desc % default.value
+          table[key] << arg + des
+        end
+      end
+      table
+    end
+
+    #------------------------------------------------------------
+    # Utility: get an array of argument examples, sorted by
+    #   length.
+    #------------------------------------------------------------
+    def example_args_by_length
+      @defaults.values
+          .sort {|a,b| a.example_arg.length <=> b.example_arg.length}
+          .collect {|d| d.example_arg}
+    end
+
+    #------------------------------------------------------------
+    # Utility: Return an array of argument groups. They will
+    #   be in the order that they were added to user defaults.
+    #------------------------------------------------------------
+    def argument_groups
+      @defaults.values
+          .collect {|default| default.help_group}
+          .uniq
+    end
+
+    #------------------------------------------------------------
+    # Returns an array of labels and the current matching value.
+    # Accepts a block to add your own pairs.
+    #------------------------------------------------------------
+    def label_value_pairs
+      result = @defaults.values.select {|default| default.item_label}
+                        .map {|default| ["#{default.item_label}:", default.value_printable]}
+      yield result if block_given?
+      result
+    end
+
+
+  end # class
+
+end # module