movie_organizer 0.1.11 → 1.0.1

data/lib/movie_organizer/movie.rb

@@ -1,33 +1,65 @@
 # frozen_string_literal: true
 
-require 'net/scp'
-require 'net/ssh'
-
 module MovieOrganizer
-  class Movie < Media
-    def initialize(filename, options)
-      super
+  class Movie < Medium
+    attr_reader :tmdb_instance
+
+    class << self
+      # Determine if the passed file is most likely a Movie.
+      # If it is, that usually means the file was named with movie title and year somwehere in
+      # the filename
+      #
+      # @return [Boolean] TmdbInstance if likely a Movie, false if not
+      def match?(filepath)
+        base          = basename(filepath)
+        possible_year = possible_year_in_title(base)
+        clean_title   = sanitize(base).gsub(/[\s\.\-\_]\(?\s*\d+\s*\)?/, '')
+        tmdb_instance = TmdbInstance.new(clean_title, possible_year)
+        return tmdb_instance if tmdb_instance.movie?
+        false
+      end
+
+      private
+
+      def possible_year_in_title(title)
+        title_with_year = sanitize(title)
+        md = title_with_year.match(/(\d+)/)
+        md ? md[1] : nil
+      end
+    end
+
+    def initialize(filename, tmdb_instance)
+      super(filename)
+      @tmdb_instance = tmdb_instance
     end
 
+    # Set the target filename
+    #
     def process!
-      target_dir = File.join(MovieOrganizer.movie_directory, "#{title} (#{year})")
-      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
+      return nil unless tmdb_instance
+      tmdb_instance.likely_match
+      @target = File.join(target_dir, processed_filename)
+      Logger.instance.info("    target file: [#{@target.green.bold}]")
     end
 
     def processed_filename
-      "#{title} (#{year})#{ext}"
+      "#{title} (#{year})#{extname}"
     end
 
     def title
-      ext_regex = Regexp.new(ext.sub(/\./, '\\.'))
-      newbase = sanitize(
-        basename.sub(/#{ext_regex}$/, '').sub(/\(?#{year}\)?/, '')
-      )
-      @title ||= newbase
+      return sanitize(basename).gsub(/[\s\.\-\_]\(?\s*\d+\s*\)?/, '') unless tmdb_instance
+      tmdb_instance.title
+    end
+
+    def year
+      return nil unless tmdb_instance
+      tmdb_instance.year
+    end
+
+    private
+
+    def target_dir
+      @target_dir ||= File.join(MovieOrganizer.movie_directory, "#{title} (#{year})")
     end
   end
 end

data/lib/movie_organizer/options.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+module MovieOrganizer
+  class Options
+    include Singleton
+
+    def [](key)
+      @@_options[key]
+    end
+
+    def hash
+      @@_options
+    end
+
+    private
+
+    def initialize_hash(hash)
+      @@_options = hash
+    end
+  end
+end

data/lib/movie_organizer/organizer.rb

@@ -18,7 +18,9 @@ module MovieOrganizer
 
     def start
       start_time = Time.now
-      @options = collect_args
+      options = MovieOrganizer::Options.instance
+      options.send(:initialize_hash, collect_args)
+
       logger.info('Starting MovieOrganizer...'.green)
       count = 0
 
@@ -28,10 +30,14 @@ module MovieOrganizer
       # 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)
+        media = Medium.build_instance(file)
+        if media.nil?
+          logger.info("Skipping [#{file}]")
+          next
+        end
         # Move and/or rename the file
         logger.info("Processing [#{file}] - #{media.class.to_s.yellow}")
-        media.process!
+        media.groom
         count += 1
       end
       elapsed = Time.now - start_time
@@ -40,28 +46,40 @@ module MovieOrganizer
 
     private
 
+    # rubocop:disable Metrics/MethodLength
     def collect_args
       Trollop.options do
         opt(
           :source_dir,
           'Source directories containing media files. Colon (:) separated.',
-          type: :string, required: false, short: '-s')
+          type: :string, required: false, short: '-s'
+        )
+        opt(
+          :copy,
+          'Copy instead of Move files',
+          type: :boolean, required: false, short: '-c',
+          default: false
+        )
         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)
+          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)
+          default: false
+        )
       end
     end
+    # rubocop:enable Metrics/MethodLength
   end
 end

data/lib/movie_organizer/settings.rb

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
+require 'singleton'
 require 'yaml'
 
 #:nocov:
 module MovieOrganizer
   # Simple class for YAML settings
   class Settings
+    include Singleton
+
     attr_reader :file
     attr_reader :config
 

data/lib/movie_organizer/string.rb

@@ -10,4 +10,12 @@ class String
     lines.map! { |c| c.sub!(/\s*\|/, '') }
     lines.join(delimeter)
   end
+
+  def escape_single_quotes!
+    gsub!(/[']/, '\\\\\'')
+  end
+
+  def escape_double_quotes!
+    gsub!(/["]/, '\\\\\"')
+  end
 end

data/lib/movie_organizer/tmdb_instance.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'themoviedb'
+
+# A cached movie lookup instance
+module MovieOrganizer
+  class TmdbInstance
+    attr_reader :title, :year, :matches
+
+    def initialize(title, year = nil)
+      Tmdb::Api.key(api_key) # configure TMDB API key
+      @title = title
+      @year  = year
+    end
+
+    def movie?
+      @matches = Tmdb::Movie.find(title)
+      sleep(0.25)
+      return self if matches.any?
+      false
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Style/RescueModifier
+    def likely_match
+      @likely_match ||= begin
+        if year.nil?
+          lm = matches.first
+          release_date = Date.parse(lm.release_date) rescue nil
+          @title = lm.title
+          @year = release_date&.year
+        else
+          lm = nil
+          matches.each do |m|
+            release_date = Date.parse(m.release_date) rescue nil
+            next unless release_date&.year.to_i == year.to_i
+            lm = m
+            @title = lm.title
+            @year = release_date&.year
+            break
+          end
+          lm ||= matches.first
+        end
+        lm
+      end
+    end
+    # rubocop:enable Style/RescueModifier
+    # rubocop:enable Metrics/AbcSize
+
+    private
+
+    def api_key
+      ENV.fetch('TMDB_KEY') do
+        Settings.instance[:movies][:tmdb_key]
+      end
+    end
+  end
+end

data/lib/movie_organizer/tv_show.rb

@@ -1,59 +1,65 @@
 # frozen_string_literal: true
 
 module MovieOrganizer
-  class TvShow < Media
+  class TvShow < Medium
+    attr_reader :tvdb_instance, :preserve_episode_name
+
     S_E_EXPRESSIONS = [
       /(s(\d+)e(\d+))/i,
-      /((\d+)x(\d+))/i,
-      /[\.\s]((\d)(\d+))[\.\s]/i
-    ]
+      /((\d+)x(\d+))/i
+    ].freeze
+
+    class << self
+      def match?(filepath)
+        index = nil
+        clean_title = nil
+        base = basename(filepath)
+        sanitized = sanitize(base)
+        S_E_EXPRESSIONS.each do |regex|
+          next unless (md = sanitized.match(regex))
+          index = sanitized.index(md[1], 0)
+          clean_title = sanitized[0..index - 1].strip
+          break
+        end
+        return false unless clean_title
+        tvdb_instance = TvdbInstance.new(clean_title)
+        return tvdb_instance if tvdb_instance.tv_show?
+        false
+      end
+    end
 
-    def initialize(filename, options)
-      super
-      @season = nil
-      @episode = nil
-      @episode_title = nil
-      @season_and_episode = nil
+    def initialize(filename, tvdb_instance)
+      super(filename)
+      @tvdb_instance         = tvdb_instance
+      @season                = nil
+      @episode               = nil
+      @episode_title         = nil
+      @season_and_episode    = nil
+      @preserve_episode_name = false
     end
 
+    # Set the target filename
+    #
     def process!
       return nil if should_skip?
-      # rename the file
-      raise "Show not configured #{basename}" if title.nil?
-      target_dir = File.join(
-        MovieOrganizer.tv_shows_directory,
-        title,
-        "Season #{season.sub(/^0+/, '')}"
-      )
-      target_file = File.join(target_dir, processed_filename)
-      logger.info("    target file: [#{target_file.green.bold}]")
-      fc = FileCopier.new(filename, target_file, options)
-      fc.copy
-    rescue ArgumentError => err
-      raise err unless err.message =~ /^same file:/
+
+      @target = File.join(target_dir, processed_filename)
+      Logger.instance.info("    target file: [#{@target.green.bold}]")
     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}"
+      if @preserve_episode_name && episode_title
+        "#{title} - #{season_and_episode} - #{episode_title}#{extname}"
       else
-        "#{title} - #{season_and_episode}#{ext}"
+        "#{title} - #{season_and_episode}#{extname}"
       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
+      tvdb_instance.match.title
     end
 
     def season
@@ -68,6 +74,14 @@ module MovieOrganizer
       filename.match(/[\.\s-]?sample[\.\s-]?/)
     end
 
+    def target_dir
+      @target_dir ||= File.join(
+        MovieOrganizer.tv_shows_directory,
+        title,
+        "Season #{season.sub(/^0+/, '')}"
+      )
+    end
+
     def episode_title
       return @episode_title unless @episode_title.nil?
       md = basename.match(/([^-]+)-([^-]+)-([^-]+)/)
@@ -77,8 +91,8 @@ module MovieOrganizer
 
     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), '')
+      base = basename.gsub(/#{title}[\.\s]*/i, '')
+      s_and_e_info = sanitize(base)
       S_E_EXPRESSIONS.each do |regex|
         md = s_and_e_info.match(regex)
         next unless md

data/lib/movie_organizer/tvdb_instance.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'tvdbr'
+
+# A cached TV show lookup instance
+module MovieOrganizer
+  class TvdbInstance
+    attr_reader :title, :year, :match, :tvdb
+
+    def initialize(title, year = nil)
+      @tvdb = Tvdbr::Client.new(api_key)
+      @title = title
+      @year  = year
+    end
+
+    def tv_show?
+      @match = tvdb.find_series_by_title(title)
+      sleep(0.25)
+      return self if @match
+      false
+    end
+
+    private
+
+    def api_key
+      ENV.fetch('TVDB_KEY') do
+        Settings.instance[:movies][:tmdb_key]
+      end
+    end
+  end
+end

data/lib/movie_organizer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MovieOrganizer
-  VERSION = '0.1.11'.freeze
+  VERSION = '1.0.1'.freeze
 end

data/lib/movie_organizer/video.rb

@@ -3,24 +3,38 @@
 require_relative 'string'
 
 module MovieOrganizer
-  class Video < Media
+  class Video < Medium
     attr_reader :settings
 
-    def initialize(filename, options)
-      @settings = Settings.new
+    VIDEO_EXTENSIONS = %w[
+      .m4v .mp4 .ogg .webm .mpeg .mpg .mov .mkv .avi
+    ].freeze
+
+    class << self
+      # This should be the last Media type to match on.
+      # Pretty much if the .ext matches video file types then consider it a video.
+      #
+      # @return [Boolean] true if matches file extensions, false if not
+      def match?(filepath)
+        return true if VIDEO_EXTENSIONS.include?(extname(filepath))
+        false
+      end
+    end
+
+    def initialize(filename)
+      @settings = Settings.instance
       super
     end
 
     def process!(file_copier = nil)
       target_file = File.join(target_dir, processed_filename)
-      logger.info("    target dir: [#{target_dir}]")
-      logger.info("    target file: [#{target_file.green.bold}]")
+      Logger.instance.info("    target file: [#{target_file.green.bold}]")
       fc = file_copier || FileCopier.new(filename, target_file, options)
-      fc.copy
+      fc.copy!
     end
 
     def processed_filename
-      "#{title} (#{year})#{ext}"
+      "#{title} (#{year})#{extname}"
     end
 
     def title
@@ -30,20 +44,34 @@ module MovieOrganizer
           |or hit enter to keep the current title
         STRING
         new_title = MovieOrganizer.prompt_for(prompt, '')
-        return File.basename(filename, ext) if new_title.nil? || new_title.empty?
+        return File.basename(filename, extname) if new_title.nil? || new_title.empty?
         new_title
       end
     end
 
     def date_time
-      filestat = File.stat(filename)
-      filestat.birthtime.strftime('%Y-%m-%d @ %l:%M %p')
+      release_date&.strftime('%Y-%m-%d @ %l:%M %p')
     end
 
-    # private
+    # Return assumed year of video.
+    # First try to get it from the filename itself
+    # Next get it from the operating system's creation date of the file
+    #
+    # @return [Fixnum] Assumed year of the video file
+    def year
+      derived = derived_year
+      return derived if derived
+      release_date&.year
+    end
 
     def target_dir
       File.join(MovieOrganizer.video_directory, "#{title} (#{date_time})")
     end
+
+    def release_date
+      st = File.stat(filename)
+      return st.birthtime unless MovieOrganizer.os == :retarded
+      st.ctime
+    end
   end
 end