royw-dvdprofiler2xbmc 0.0.5 → 0.0.6

data/lib/dvdprofiler2xbmc/{media_files.rb → models/media_files.rb}

@@ -5,8 +5,7 @@ class MediaFiles
 
   # given:
   # directories Array of String directory pathspecs
-  def initialize(directories, collection)
-    @collection = collection
+  def initialize(directories)
     @medias = find_medias(directories)
     @titles = find_titles(@medias)
     @duplicate_titles = find_duplicate_titles(@titles)
@@ -20,7 +19,7 @@ class MediaFiles
     directories.each do |dir|
       Dir.chdir(dir)
       medias += Dir.glob("**/*.{#{AppConfig[:media_extensions].join(',')}}").collect do |filename|
-        Media.new(dir, filename, @collection)
+        Media.new(dir, filename)
       end
     end
     medias

data/lib/dvdprofiler2xbmc/models/tmdb_movie.rb

@@ -0,0 +1,136 @@
+class TmdbMovie
+
+  attr_reader :query, :document
+
+  API_KEY = '7a2f6eb9b6aa01651000f0a9324db835'
+
+  def initialize(ident)
+    @imdb_id = 'tt' + ident.gsub(/^tt/, '') unless ident.blank?
+    @query = "http://api.themoviedb.org/2.0/Movie.imdbLookup?imdb_id=#{@imdb_id}&api_key=#{API_KEY}"
+  end
+
+  def fanarts
+    result = []
+    begin
+      document['moviematches'].each do |moviematches|
+        moviematches['movie'].each do |movie|
+          backdrop = movie['backdrop']
+          unless backdrop.blank?
+            result += backdrop
+          end
+        end
+      end
+    rescue
+    end
+    result
+  end
+
+  def posters
+    result = []
+    begin
+      document['moviematches'].each do |moviematches|
+        moviematches['movie'].each do |movie|
+          result += movie['poster']
+        end
+      end
+    rescue
+    end
+    result
+  end
+
+  def idents
+    document['moviematches'].first['movie'].first['id']  rescue nil
+  end
+
+  def urls
+    document['moviematches'].first['movie'].first['url']  rescue nil
+  end
+
+  def imdb_ids
+    document['moviematches'].first['movie'].first['imdb']  rescue nil
+  end
+
+  def titles
+    document['moviematches'].first['movie'].first['title']  rescue nil
+  end
+
+  def short_overviews
+    document['moviematches'].first['movie'].first['short_overview']  rescue nil
+  end
+
+  def types
+    document['moviematches'].first['movie'].first['type']  rescue nil
+  end
+
+  def alternative_titles
+    document['moviematches'].first['movie'].first['alternative_title']  rescue nil
+  end
+
+  def releases
+    document['moviematches'].first['movie'].first['release']  rescue nil
+  end
+
+  def scores
+    document['moviematches'].first['movie'].first['score']  rescue nil
+  end
+
+  def to_hash
+    hash = {}
+    [:fanarts, :posters, :idents, :urls, :imdb_ids, :titles, :short_overviews,
+     :types, :alternative_titles, :releases, :scores
+    ].each do |sym|
+      begin
+        value = send(sym.to_s)
+        hash[sym.to_s] = value unless value.nil?
+      rescue Exception => e
+        puts "Error getting data for hash for #{sym} - #{e.to_s}"
+      end
+    end
+    hash
+  end
+
+  def to_xml
+    XmlSimple.xml_out(document, 'NoAttr' => true, 'RootName' => 'movie')
+  end
+
+  def to_yaml
+    YAML.dump(document)
+  end
+
+  private
+
+    # Fetch the document with retry to handle the occasional glitches
+  def document
+    if @document.nil?
+      html = fetch(self.query)
+      @document = XmlSimple.xml_in(html)
+      @document = nil if @document['totalResults'] == ['0']
+    end
+    @document
+  end
+
+  MAX_ATTEMPTS = 3
+  SECONDS_BETWEEN_RETRIES = 1.0
+
+  def fetch(page)
+    doc = nil
+    attempts = 0
+    begin
+      doc = read_page(page)
+    rescue Exception => e
+      attempts += 1
+      if attempts > MAX_ATTEMPTS
+        raise
+      else
+        sleep SECONDS_BETWEEN_RETRIES
+        retry
+      end
+    end
+    doc
+  end
+
+  def read_page(page)
+    open(page).read
+  end
+
+end

data/lib/dvdprofiler2xbmc/models/tmdb_profile.rb

@@ -0,0 +1,112 @@
+# This is the model for the themovieDb profile which is used
+# to find TmdbMovie meta data from either online or from
+# a cached file.
+#
+# Usage:
+#
+# profile = TmdbProfile.first(:imdb_id => 'tt0123456')
+#
+# puts profile.movie['key'].first
+# puts profile.to_xml
+# puts profile.imdb_id
+#
+class TmdbProfile
+
+  # options:
+  #  :imdb_id => String (either with or without leading 'tt')
+  def self.all(options={})
+    result = []
+    if has_option?(options, :imdb_id)
+      result << TmdbProfile.new(options[:imdb_id], options[:filespec])
+    end
+    result
+  end
+
+  def self.first(options={})
+    self.all(options).first
+  end
+
+  # this is intended to be stubed by rspec where it
+  # should return true.
+  def self.use_html_cache
+    false
+  end
+
+  protected
+
+  def self.has_option?(options, key)
+    options.has_key?(key) && !options[key].blank?
+  end
+
+  def initialize(ident, filespec=nil)
+    @imdb_id = ident
+    @filespec = filespec
+    load
+  end
+
+
+  public
+
+  attr_reader :imdb_id, :movie
+
+  def to_xml
+    xml = ''
+    unless @movie.blank?
+      @movie.delete_if { |key, value| value.nil? }
+      xml = XmlSimple.xml_out(@movie, 'NoAttr' => true, 'RootName' => 'movie')
+    end
+    xml
+  end
+
+  protected
+
+  def load
+    @movie = nil
+    if !@filespec.blank? && File.exist?(@filespec)
+      AppConfig[:logger].debug { "loading movie filespec=> #{@filespec.inspect}" }
+      @movie = from_xml(open(@filespec).read)
+    elsif !@imdb_id.blank?
+      AppConfig[:logger].debug { "loading movie from tmdb.com, filespec=> #{@filespec.inspect}" }
+      @movie = TmdbMovie.new(@imdb_id.gsub(/^tt/, '')).to_hash
+      save(@filespec) unless @filespec.blank?
+    end
+    if @movie.blank?
+      @movie = nil
+    end
+  end
+
+  def from_xml(xml)
+    begin
+      movie = XmlSimple.xml_in(xml)
+    rescue Exception => e
+      AppConfig[:logger].warn { "Error converting from xml: #{e.to_s}" }
+      movie = nil
+    end
+    movie
+  end
+
+  def save(filespec)
+    begin
+      xml = self.to_xml
+      unless xml.blank?
+        AppConfig[:logger].debug { "saving #{filespec}" }
+        save_to_file(filespec, xml)
+      end
+    rescue Exception => e
+      AppConfig[:logger].error "Unable to save tmdb profile to #{filespec} - #{e.to_s}"
+    end
+  end
+
+  def save_to_file(filespec, data)
+    new_filespec = filespec + AppConfig[:new_extension]
+    File.open(new_filespec, "w") do |file|
+      file.puts(data)
+    end
+    backup_filespec = filespec + AppConfig[:backup_extension]
+    File.delete(backup_filespec) if File.exist?(backup_filespec)
+    File.rename(filespec, backup_filespec) if File.exist?(filespec)
+    File.rename(new_filespec, filespec)
+    File.delete(new_filespec) if File.exist?(new_filespec)
+  end
+
+end

data/lib/dvdprofiler2xbmc/models/xbmc_info.rb

@@ -0,0 +1,124 @@
+# This is the model for the XBMC's Info profile which is used
+# to manage a .nfo file
+#
+# Usage:
+#
+# profile = XbmcInfo.new(media.path_to(:nfo_extension))
+#
+# profile.movie['key'] = 'some value'
+# puts profile.movie['key']
+# puts profile.to_xml
+# puts profile.save
+#
+class XbmcInfo
+
+  FILTER_HTML = /<[^>]*>/
+
+  def initialize(filespec)
+    @nfo_filespec = filespec
+    @movie = nil
+    @original_movie = nil
+    load
+  end
+
+  def movie
+    @movie ||= Hash.new
+    @movie
+  end
+
+  def movie=(other)
+    @movie = other
+  end
+
+  # convert the @movie hash into xml and return the xml as a String
+  def to_xml
+    xml = ''
+    begin
+      unless @movie.blank?
+        data = @movie.dup
+        data.delete_if { |key, value| value.nil? }
+        %w(plot tagline overview).each do |key|
+          if data[key].respond_to?('first')
+            data[key] = data[key].first
+          end
+          data[key] = data[key].gsub(FILTER_HTML, '') unless data[key].blank?
+        end
+        xml = XmlSimple.xml_out(data, 'NoAttr' => true, 'RootName' => 'movie')
+      end
+    rescue Exception => e
+      AppConfig[:logger].error { "Error creating nfo file - " + e.to_s}
+      raise e
+    end
+    xml
+  end
+
+  def save
+    begin
+      if dirty?
+        xml = self.to_xml
+        unless xml.blank?
+          AppConfig[:logger].info { "updated #{@nfo_filespec}"}
+          save_to_file(@nfo_filespec, xml)
+        end
+      end
+    rescue Exception => e
+      AppConfig[:logger].error "Unable to save xbmc info to #{@nfo_filespec} - #{e.to_s}"
+    end
+  end
+
+  protected
+
+  # load the .nfo file into the @movie hash
+  def load
+    begin
+      if File.exist?(@nfo_filespec) && (File.size(@nfo_filespec) > 1)
+        File.open(@nfo_filespec) do |file|
+          @movie = XmlSimple.xml_in(file)
+          @original_movie = @movie.dup
+        end
+      end
+    rescue Exception => e
+      AppConfig[:logger].error { "Error loading \"#{@nfo_filespec}\" - " + e.to_s + "\n" + e.backtrace.join("\n") }
+      raise e
+    end
+  end
+
+  def save_to_file(filespec, data)
+    new_filespec = filespec + AppConfig[:new_extension]
+    File.open(new_filespec, "w") do |file|
+      file.puts(data)
+    end
+    backup_filespec = filespec + AppConfig[:backup_extension]
+    File.delete(backup_filespec) if File.exist?(backup_filespec)
+    File.rename(filespec, backup_filespec) if File.exist?(filespec)
+    File.rename(new_filespec, filespec)
+    File.delete(new_filespec) if File.exist?(new_filespec)
+  end
+
+  # has any of the data changed?
+  def dirty?
+    result = false
+    if @original_movie.nil?
+      result = true
+    else
+      @movie.each do |key, value|
+        if @original_movie[key].nil?
+          result = true
+          break
+        end
+        if @movie[key].to_s != @original_movie[key].to_s
+          result = true
+          break
+        end
+      end
+      unless result
+        diff_keys = @movie.keys.sort - @original_movie.keys.sort
+        unless diff_keys.empty?
+          result = true
+        end
+      end
+    end
+    result
+  end
+
+end

data/lib/dvdprofiler2xbmc/open_cache_extension.rb

@@ -0,0 +1,39 @@
+
+#
+class Kernel
+  attr_accessor :html_cache_dir
+  @html_cache_dir = '/tmp'
+
+  # cache any files read using http protocol
+  def open_cache(url)
+    if url =~ /^https?:\/\//i
+      filespec = url.gsub(/^http:\//, @html_cache_dir).gsub(/\/$/, '.html')
+      begin
+        fh = open(filespec)
+      rescue Exception
+        fh = open(url)
+        cache_html_files(filespec, fh.read)
+        fh.rewind
+      end
+    else
+      fh = open(url)
+    end
+    fh
+  end
+
+  private
+
+  # this is used to save imdb pages so they may be used by rspec
+  def cache_html_files(filespec, html)
+    begin
+      unless File.exist?(filespec)
+        puts "caching #{filespec}"
+        File.mkdirs(File.dirname(filespec))
+        File.open(filespec, 'w') { |f| f.puts html }
+      end
+    rescue Exception => eMsg
+      puts eMsg.to_s
+    end
+  end
+
+end

data/lib/dvdprofiler2xbmc/views/cli.rb

@@ -0,0 +1,171 @@
+require 'commandline/optionparser'
+include CommandLine
+
+# Command Line interface for the Dvdprofiler2Xbmc application.
+# All application output is via AppConfig[:logger] so we have
+# to set up the logger here.
+# Also handle the command line options.
+# Finally creates an instance of Dvdprofiler2Xbmc and executes
+# it.
+
+module Dvdprofiler2xbmc
+  # == Synopsis
+  # Command line exit codes
+  class ExitCode
+    UNKNOWN = 3
+    CRITICAL = 2
+    WARNING = 1
+    OK = 0
+  end
+
+  class CLI
+    include AppConfig
+
+    def self.execute(stdout, arguments=[])
+      exit_code = ExitCode::OK
+
+      # we start a STDOUT logger, but it will be switched after
+      # the config files are read if config[:logger_output] is set
+
+      begin
+        # trap ^C interrupts and let the app instance cleanly exit any long loops
+        Signal.trap("INT") {DvdProfiler2Xbmc.interrupt}
+
+        logger = setup_logger
+
+        # parse the command line
+        options = setup_parser()
+        od = options.parse(arguments)
+
+        setup_app_config(od, logger)
+
+        unless od["--help"] || od["--version"]
+          # create and execute class instance here
+          app = DvdProfiler2Xbmc.instance
+          app.execute
+          app.report.each {|line| AppConfig[:logger].info line}
+        end
+      rescue Exception => eMsg
+        logger.error {eMsg.to_s}
+        logger.error {options.to_s}
+        logger.error {eMsg.backtrace.join("\n")}
+        exit_code = ExitCode::CRITICAL
+      end
+      exit_code
+    end
+
+    def self.setup_app_config(od, logger)
+      # load config values
+      AppConfig.default
+
+      # the first reinitialize_logger adds the command line logging options to the default config
+      # then we load the config files
+      # then we run reinitialize_logger again to modify the logger for any logging options from the config files
+
+      reinitialize_logger(logger, od["--quiet"], od["--debug"])
+      AppConfig.load
+      AppConfig.save
+      AppConfig[:imdb_query] = !od["--no_imdb_query"]
+      AppConfig[:logfile] = od['--output'] if od['--output']
+      AppConfig[:logfile_level] = od['--output_level'] if od['--output_level']
+      reinitialize_logger(logger, od["--quiet"], od["--debug"])
+
+      AppConfig[:do_update] = !od["--reports"]
+      AppConfig[:force_nfo_replacement] = od["--force_nfo_replacement"]
+
+      AppConfig[:logger].info { "logfile => #{AppConfig[:logfile].inspect}" } unless AppConfig[:logfile].nil?
+      AppConfig[:logger].info { "logfile_level => #{AppConfig[:logfile_level].inspect}" } unless AppConfig[:logfile_level].nil?
+    end
+
+    # Setup the command line option parser
+    # Returns:: OptionParser instances
+    def self.setup_parser()
+      options = OptionParser.new()
+
+      # flag options
+      [
+        {
+          :names           => %w(--version -v),
+          :opt_found       => lambda {Log4r::Logger['dvdprofiler2xbmc'].info{"Dvdprofiler2xbmc #{Dvdprofiler2xbmc::VERSION}"}},
+          :opt_description => "This version of dvdprofiler2xbmc"
+        },
+        {
+          :names           => %w(--help -h),
+          :opt_found       => lambda {Log4r::Logger['dvdprofiler2xbmc'].info{options.to_s}},
+          :opt_description => "This usage information"
+        },
+        {
+          :names           => %w(--no_imdb_query -n),
+          :opt_description => 'Do not query IMDB.com'
+        },
+        {
+          :names           => %w(--quiet -q),
+          :opt_description => 'Display error messages only'
+        },
+        {
+          :names           => %w(--debug -d),
+          :opt_description => 'Display debug messages'
+        },
+        {
+          :names           => %w(--force_nfo_replacement -f),
+          :opt_description => 'Delete old .nfo files and generate new ones'
+        },
+        {
+          :names           => %w(--reports -r),
+          :opt_description => 'Display reports only.  Do not do any updates.'
+        }
+      ].each { |opt| options << Option.new(:flag, opt) }
+
+      # non-flag options
+      [
+        {
+          :names           => %w(--output -o),
+          :argument_arity  => [1,1],
+          :arg_description => 'logfile',
+          :opt_description => 'Write log messages to file. Default = no log file',
+          :opt_found       => OptionParser::GET_ARGS
+        },
+        {
+          :names           => %w(--output_level -l),
+          :argument_arity  => [1,1],
+          :arg_description => 'level',
+          :opt_description => 'Output logging level: DEBUG, INFO, WARN, ERROR. Default = INFO',
+          :opt_found       => OptionParser::GET_ARGS
+        }
+      ].each { |opt| options << Option.new(opt) }
+
+      options
+    end
+
+    # Initial setup of logger
+    def self.setup_logger
+      logger = Log4r::Logger.new('dvdprofiler2xbmc')
+      logger.outputters = Log4r::StdoutOutputter.new(:console)
+      Log4r::Outputter[:console].formatter  = Log4r::PatternFormatter.new(:pattern => "%m")
+      logger.level = Log4r::DEBUG
+      logger
+    end
+
+    # Reinitialize the logger using the loaded config.
+    # logger:: logger for any user messages
+    # config:: is the application's config hash.
+    def self.reinitialize_logger(logger, quiet, debug)
+      # switch the logger to the one specified in the config files
+      unless AppConfig[:logfile].blank?
+        logfile_outputter = Log4r::RollingFileOutputter.new(:logfile, :filename => AppConfig[:logfile], :maxsize => 1000000 )
+        logger.add logfile_outputter
+        AppConfig[:logfile_level] ||= 'INFO'
+        Log4r::Outputter[:logfile].formatter = Log4r::PatternFormatter.new(:pattern => "[%l] %d :: %M")
+        level_map = {'DEBUG' => Log4r::DEBUG, 'INFO' => Log4r::INFO, 'WARN' => Log4r::WARN}
+        logfile_outputter.level = level_map[AppConfig[:logfile_level].upcase] || Log4r::INFO
+      end
+      Log4r::Outputter[:console].level = Log4r::INFO
+      Log4r::Outputter[:console].level = Log4r::WARN if quiet
+      Log4r::Outputter[:console].level = Log4r::DEBUG if debug
+      Log4r::Outputter[:console].formatter = Log4r::PatternFormatter.new(:pattern => "%m")
+                                                                                       # logger.trace = true
+      AppConfig[:logger] = logger
+    end
+  end
+end
+