movie_organizer 0.1.0

data/lib/movie_organizer/media.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'titleize'
+require 'streamio-ffmpeg'
+require 'themoviedb'
+
+module MovieOrganizer
+  # This meta-class factory accepts the media filename, and from that
+  # determines if it is likely to be:
+  #
+  # 1. a TV show
+  # 2. a Movie
+  # 3. a home video or other type
+  class Media
+    attr_accessor :filename, :options, :logger, :settings
+
+    def self.subtype(filename, options)
+      instance = new(filename, options)
+      return TvShow.new(filename, options) if instance.tv_show?
+      return Movie.new(filename, options) if instance.movie?
+      Video.new(filename, options)
+    end
+
+    def initialize(filename, options)
+      @filename = filename
+      @options = options
+      @tv_show = nil
+      @logger = Logger.instance
+      @settings = Settings.new
+    end
+
+    def tv_show?
+      return @tv_show unless @tv_show.nil?
+      @tv_show = false
+      @tv_show = true unless filename.match(/S\d+E\d+/i).nil?
+      @tv_show = true unless filename.match(/\d+x\d+/i).nil?
+      @tv_show
+    end
+
+    def movie?
+      return @movie unless @movie.nil?
+      @movie = false
+      Tmdb::Api.key(settings[:movies][:tmdb_key])
+      title = sanitize(File.basename(filename, ext)).gsub(/\d\d\d\d/, '').strip
+      matches = Tmdb::Movie.find(title)
+      @movie = matches.any?
+      @movie
+    end
+
+    def year
+      md = basename.match(/\((\d\d\d\d)\)|(19\d\d)|(20\d\d)/)
+      md ? md.captures.compact.first : nil
+    end
+
+    protected
+
+    def basename
+      File.basename(filename)
+    end
+
+    def ext
+      File.extname(filename)
+    end
+
+    def verbose?
+      options[:verbose]
+    end
+
+    def dry_run?
+      options[:dry_run]
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def sanitize(str)
+      cleanstr = str.gsub(/-\s*-/, '')
+      cleanstr = cleanstr.gsub(/\[?1080p\]?/, '').strip
+      cleanstr = cleanstr.gsub(/\[?720p\]?/, '').strip
+      cleanstr = cleanstr.gsub(/\[[^\]]+\]/, '').strip
+      cleanstr = cleanstr.gsub(/EXTENDED/, '').strip
+      cleanstr = cleanstr.gsub(/YIFY/, '').strip
+      cleanstr = cleanstr.gsub(/VPPV/, '').strip
+      cleanstr = cleanstr.gsub(/BluRay/i, '').strip
+      cleanstr = cleanstr.gsub(/BrRip/i, '').strip
+      cleanstr = cleanstr.gsub(/ECI/i, '').strip
+      cleanstr = cleanstr.gsub(/HDTV/i, '').strip
+      cleanstr = cleanstr.gsub(/x264/, '').strip
+      cleanstr = cleanstr.gsub(/-lol/i, '').strip
+      # cleanstr = cleanstr.gsub(/[\.\s-]us[\.\s-]/i, ' ').strip
+      cleanstr = cleanstr.gsub(/-\s*/, '').strip
+      cleanstr = cleanstr.gsub(/\s\s+/, ' ').strip
+      cleanstr.gsub(/[\.\+]/, ' ').strip
+    end
+    # rubocop:enable Metrics/AbcSize
+  end
+end

data/lib/movie_organizer/media_list.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'mime/types'
+
+module MovieOrganizer
+  class MediaList
+    attr_accessor :file_collection
+
+    # Walk the source_directories finding all pertinent media files
+    def initialize(directories = MovieOrganizer.source_directories)
+      @file_collection = []
+      directories.each do |directory|
+        Dir["#{directory}/**/*"].each do |entry|
+          file_collection << entry if media?(entry)
+        end
+      end
+    end
+
+    def media?(filename)
+      video?(filename) || subtitle?(filename)
+    end
+
+    def video?(filename)
+      MIME::Types.of(filename).map(&:media_type).include?('video')
+    end
+
+    def subtitle?(filename)
+      !MIME::Types.of(filename).map(&:content_type).grep(/(subtitle$|subrip$)/).empty?
+    end
+  end
+end

data/lib/movie_organizer/movie.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'net/scp'
+require 'net/ssh'
+
+module MovieOrganizer
+  class Movie < Media
+    def initialize(filename, options)
+      super
+    end
+
+    def process!
+      settings = Settings.new
+      target_dir = File.join(
+        settings[:movies][:directory],
+        "#{title} (#{year})"
+      )
+      FileUtils.mkdir_p(target_dir, noop: dry_run?)
+      target_file = File.join(
+        target_dir,
+        processed_filename
+      )
+      logger.info("    target dir: [#{target_dir}]")
+      logger.info("    target file: [#{target_file.green.bold}]")
+      fc = FileCopier.new(filename, target_file, options)
+      fc.copy
+    end
+
+    def processed_filename
+      "#{title} (#{year})#{ext}"
+    end
+
+    def title
+      ext_regex = Regexp.new(ext.sub(/\./, '\\.'))
+      newbase = sanitize(
+        basename.sub(/#{ext_regex}$/, '').sub(/\(?#{year}\)?/, '')
+      )
+      @title ||= newbase
+    end
+  end
+end

data/lib/movie_organizer/organizer.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'pry'
+require 'trollop'
+require 'colored'
+
+module MovieOrganizer
+  class Organizer
+    attr_accessor :logger, :options
+
+    # Make a singleton but allow the class to be instantiated for easier testing
+    def self.instance
+      @instance || new
+    end
+
+    def initialize
+      @logger = Logger.instance
+    end
+
+    def start
+      start_time = Time.now
+      @options = collect_args
+      logger.info('Starting MovieOrganizer...'.green)
+      count = 0
+
+      # Enumerate all of the new source media
+      @media_list = MediaList.new(MovieOrganizer.source_directories)
+
+      # Process each source file
+      @media_list.file_collection.each do |file|
+        # Get movie or TV show information so we can rename the file if necessary
+        media = Media.subtype(file, options)
+        # Move and/or rename the file
+        logger.info("Processing [#{file}] - #{media.class.to_s.yellow}")
+        media.process!
+        count += 1
+      end
+      elapsed = Time.now - start_time
+      logger.info("Processed #{count} vidoes in [#{elapsed}] seconds.".yellow)
+    end
+
+    private
+
+    def collect_args
+      Trollop.options do
+        opt(
+          :source_dir,
+          'Source directories containing media files. Colon (:) separated.',
+          type: :string, required: false, short: '-s')
+        opt(
+          :dry_run,
+          'Do not actually move or copy files',
+          type: :boolean, required: false, short: '-d',
+          default: false)
+        opt(
+          :preserve_episode_name,
+          'Preserve episode names if they exist (experimental)',
+          type: :boolean, required: false, short: '-p',
+          default: false)
+        opt(
+          :verbose,
+          'Be verbose with output',
+          type: :boolean, required: false, short: '-v',
+          default: false)
+      end
+    end
+  end
+end

data/lib/movie_organizer/settings.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+#:nocov:
+module MovieOrganizer
+  # Simple class for YAML settings
+  class Settings
+    attr_reader :file
+    attr_reader :config
+
+    def initialize(file = MovieOrganizer.config_file)
+      @file = file
+    end
+
+    def load
+      @config ||= YAML.load_file(file) || {}
+      self
+    end
+
+    def save
+      File.open(file, 'w') { |thefile| thefile.write(YAML.dump(config)) }
+      self
+    end
+
+    def [](key)
+      load
+      config[key]
+    end
+
+    def []=(key, value)
+      load
+      config[key] = value
+    end
+
+    def data
+      load
+      config
+    end
+
+    def all
+      load
+      config
+    end
+  end
+end
+#:nocov:

data/lib/movie_organizer/string.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class String
+  # html = <<-stop.here_with_pipe(delimeter="\n")
+  #   |<!-- Begin: comment  -->
+  #   |<script type="text/javascript">
+  # stop
+  def here_with_pipe(delimeter = ' ')
+    lines = split("\n")
+    lines.map! { |c| c.sub!(/\s*\|/, '') }
+    lines.join(delimeter)
+  end
+end

data/lib/movie_organizer/tv_show.rb

@@ -0,0 +1,96 @@
+module MovieOrganizer
+  class TvShow < Media
+    S_E_EXPRESSIONS = [
+      /(s(\d+)e(\d+))/i,
+      /((\d+)x(\d+))/i,
+      /[\.\s]((\d)(\d+))[\.\s]/i
+    ]
+
+    def initialize(filename, options)
+      super
+      @season = nil
+      @episode = nil
+      @episode_title = nil
+      @season_and_episode = nil
+    end
+
+    def process!
+      return nil if should_skip?
+      # rename the file
+      fail "Show not configured #{basename}" if title.nil?
+      target_dir = File.join(
+        settings[:tv_shows][:directory],
+        title,
+        "Season #{season.sub(/^0+/, '')}"
+      )
+      FileUtils.mkdir_p(target_dir, noop: dry_run?)
+      target_file = File.join(target_dir, processed_filename)
+      logger.info("    target dir: [#{target_dir}]")
+      logger.info("    target file: [#{target_file.green.bold}]")
+      FileUtils.move(
+        filename,
+        target_file,
+        force: true, noop: dry_run?
+      )
+    rescue ArgumentError => err
+      raise err unless err.message.match(/^same file:/)
+    end
+
+    # Standardize the filename
+    # @return [String] cleaned filename
+    def processed_filename
+      return nil if should_skip?
+      if options[:preserve_episode_name] && episode_title
+        "#{title} - #{season_and_episode} - #{episode_title}#{ext}"
+      else
+        "#{title} - #{season_and_episode}#{ext}"
+      end
+    end
+
+    def title
+      return @title unless @title.nil?
+      settings[:tv_shows][:my_shows].each do |show|
+        md = sanitize(basename).match(Regexp.new(sanitize(show), Regexp::IGNORECASE))
+        if md
+          @title = md[0].titleize
+          return @title
+        end
+      end
+      @title
+    end
+
+    def season
+      return @season unless @season.nil?
+      season_and_episode
+      @season
+    end
+
+    private
+
+    def should_skip?
+      filename.match(/[\.\s-]?sample[\.\s-]?/)
+    end
+
+    def episode_title
+      return @episode_title unless @episode_title.nil?
+      md = basename.match(/([^-]+)-([^-]+)-([^-]+)/)
+      @episode_title = md[3].sub(/#{ext}$/, '').strip if md
+      @episode_title
+    end
+
+    def season_and_episode
+      return @season_and_episode unless @season_and_episode.nil?
+      clean_basename = sanitize(basename)
+      s_and_e_info = clean_basename.sub(Regexp.new(title, Regexp::IGNORECASE), '')
+      S_E_EXPRESSIONS.each do |regex|
+        md = s_and_e_info.match(regex)
+        next unless md
+        @season = md[2].rjust(2, '0')
+        @episode = md[3].rjust(2, '0')
+        @season_and_episode = "S#{@season}E#{@episode}"
+        return @season_and_episode
+      end
+      @season_and_episode
+    end
+  end
+end

data/lib/movie_organizer/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module MovieOrganizer
+  VERSION = '0.1.0'
+end

data/lib/movie_organizer/video.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module MovieOrganizer
+  class Video < Media
+    attr_reader :settings
+
+    def initialize(filename, options)
+      @settings = Settings.new
+      super
+    end
+
+    def process!
+      binding.pry
+      FileUtils.mkdir_p(target_dir, noop: dry_run?)
+      logger.info("    target dir: [#{target_dir}]")
+      logger.info("    target file: [#{target_file.green.bold}]")
+      FileUtils.move(filename, target_file, force: true, noop: dry_run?)
+    end
+
+    def processed_filename
+      "#{title} (#{year})#{ext}"
+    end
+
+    def title
+      @title ||= begin
+        temp = MovieOrganizer.prompt_for(
+          <<-STRING.here_with_pipe(' ')
+            |Please enter a friendly title for this video: [#{filename}]
+            |or just hit enter to keep the current title
+          STRING
+        )
+        binding.pry
+      end
+    end
+
+    def date_time
+      filestat = File.stat(filename)
+      filestat.birthtime.strftime('%Y-%m-%d @ %l:%M %p')
+    end
+
+    # private
+
+    def target_dir
+      File.join(settings[:videos][:directory], "#{title} (#{date_time})")
+    end
+  end
+end