opensubtitles 0.0.1

data/lib/opensubtitles/movie_file.rb

@@ -0,0 +1,67 @@
+module Opensubtitles
+  class MovieFile
+
+    EXTENSIONS = %w(avi mpg m4v mkv mov ogv mp4)
+
+    attr_reader :path, :language
+
+    def initialize(path, language = Opensubtitles.default_language)
+      @path = path
+      @language = language
+    end
+
+    def has_sub?
+      exist = false
+      %w(srt sub).each{ |ext| exist ||= File.exist?(sub_path(ext)) }
+      exist
+    end
+
+    def sub_path(format)
+      extension = if @language
+        ".#{@language}.#{format}"
+      else
+        ".#{format}"
+      end
+      File.join(File.dirname(path), File.basename(path, File.extname(path)) + extension)
+    end
+    
+    def hash
+      @hash ||= self.class.compute_hash(path)
+    end
+    
+    def size
+      @size ||= File.size(path)
+    end
+
+    def name
+      @name ||= File.basename(path, File.extname(path))
+    end
+    
+    CHUNK_SIZE = 64 * 1024 # in bytes
+    
+    # from http://trac.opensubtitles.org/projects/opensubtitles/wiki/HashSourceCodes
+    def self.compute_hash(path)
+      filesize = File.size(path)
+      hash = filesize
+      
+      # Read 64 kbytes, divide up into 64 bits and add each
+      # to hash. Do for beginning and end of file.
+      File.open(path, 'rb') do |f|    
+        # Q = unsigned long long = 64 bit
+        f.read(CHUNK_SIZE).unpack("Q*").each do |n|
+          hash = hash + n & 0xffffffffffffffff # to remain as 64 bit number
+        end
+        
+        f.seek([0, filesize - CHUNK_SIZE].max, IO::SEEK_SET)
+        
+        # And again for the end of the file
+        f.read(CHUNK_SIZE).unpack("Q*").each do |n|
+          hash = hash + n & 0xffffffffffffffff
+        end
+      end
+      
+      sprintf("%016x", hash)
+    end
+
+  end
+end

data/lib/opensubtitles/search.rb

@@ -0,0 +1,9 @@
+module Opensubtitles
+  module Search
+    base_path = File.expand_path(File.dirname(__FILE__) + '/search')
+    autoload :IMDB,       "#{base_path}/imdb"
+    autoload :MovieHash,  "#{base_path}/movie_hash"
+    autoload :Name,       "#{base_path}/name"
+    autoload :Path,       "#{base_path}/path"
+  end
+end

data/lib/opensubtitles/search/imdb.rb

@@ -0,0 +1,27 @@
+module Opensubtitles
+  module Search
+
+    class IMDB
+
+      def initialize(server, selector=Finder::First.new)
+        @server = server
+        @selector = selector
+      end
+
+      def search_subs_for(movie, language)
+        imdb_results = @server.search_imdb(:query => movie.name)
+        return if imdb_results.size == 0
+        return if imdb_results.class != Hash
+        return if imdb_results[:imdbid] == nil
+        if imdb_result = @selector.chose(imdb_results)
+          @server.search_subtitles(
+            :sublanguageid => language,
+            :imdbid => imdb_result.imdbid
+          )
+        end
+      end
+
+    end
+
+  end
+end

data/lib/opensubtitles/search/movie_hash.rb

@@ -0,0 +1,21 @@
+module Opensubtitles
+  module Search
+
+    class MovieHash
+
+      def initialize(server)
+        @server = server
+      end
+
+      def search_subs_for(movie, language)
+        @server.search_subtitles(
+          :moviehash => movie.hash,
+          :moviebytesize => movie.size.to_s,
+          :sublanguageid => language
+        )
+      end
+
+    end
+
+  end
+end

data/lib/opensubtitles/search/name.rb

@@ -0,0 +1,28 @@
+module Opensubtitles
+  module Search
+
+    class Name
+
+      def initialize(server)
+        @server = server
+      end
+
+      def search_subs_for(movie, language)
+        subs = @server.search_subtitles(:sublanguageid => language, :query => movie.name)
+        normalized_movie_name = normalize_name(movie.name)
+        subs.select! do |sub|
+          normalize_name(sub.filename).index(normalized_movie_name) # MAYBE: Levenshtein ?
+        end
+        subs
+      end
+
+      protected
+
+      def normalize_name(name)
+        name.downcase.gsub(/[\s\.\-\_]+/, ' ')
+      end
+
+    end
+
+  end
+end

data/lib/opensubtitles/search/path.rb

@@ -0,0 +1,20 @@
+module Opensubtitles
+  module Search
+
+    class Path
+
+      def initialize(server)
+        @server = server
+      end
+
+      def search_subs_for(movie, language)
+        @server.search_subtitles(
+          :sublanguageid => language,
+          :tag => movie.path
+        )
+      end
+
+    end
+
+  end
+end

data/lib/opensubtitles/selector.rb

@@ -0,0 +1,7 @@
+module Opensubtitles
+  module Selector
+    base_path = File.expand_path(File.dirname(__FILE__) + '/selector')
+    autoload :Format, "#{base_path}/format"
+    autoload :Movie,  "#{base_path}/movie"
+  end
+end

data/lib/opensubtitles/selector/format.rb

@@ -0,0 +1,17 @@
+module Opensubtitles
+  module Selector
+
+    class Format
+
+      def initialize(formats)
+        @formats = formats
+      end
+
+      def select(subs, movie)
+        subs.select{ |s| @formats.include?(s.format) }
+      end
+
+    end
+
+  end
+end

data/lib/opensubtitles/selector/movie.rb

@@ -0,0 +1,29 @@
+module Opensubtitles
+  module Selector
+
+    class Movie
+
+      def initialize(movie_finder=Finder::First.new)
+        @movie_finder = movie_finder
+      end
+
+      def select(subs, movie)
+        subs_by_movie = group_by_movie_name(subs)
+        return subs if subs_by_movie.length <= 1
+        movie_names = subs_by_movie.keys
+        movie_name = @movie_finder.chose(movie_names)
+        subs_by_movie[movie_name] || []
+      end
+
+      def group_by_movie_name(subs)
+        subs.inject({}) do |hash, sub|
+          hash[sub.movie_name] ||= []
+          hash[sub.movie_name] << sub
+          hash
+        end
+      end
+
+    end
+
+  end
+end

data/lib/opensubtitles/server.rb

@@ -0,0 +1,70 @@
+require 'ostruct'
+
+module Opensubtitles
+
+  class LoginFailed < ::Exception
+  end
+
+  class Server
+
+    attr_reader :username, :password, :language, :useragent, :client
+
+    CLIENT_ARGS = [:host, :path, :port, :proxy_host, :proxy_port, :http_user, :http_password, :use_ssl, :timeout]
+
+    DEFAULT_OPTIONS = {
+      :host => 'api.opensubtitles.org',
+      :path => '/xml-rpc',
+      :timeout => 10
+    }.freeze
+
+    def initialize(options={})
+      @username = options[:username] || ''
+      @password = options[:password] || ''
+      @language = options[:language] || 'eng'
+      @useragent = options[:useragent] || 'opensubtitles v0.1'
+      options = DEFAULT_OPTIONS.merge(options)
+      @client = ::XMLRPC::Client.new(*options.values_at(*CLIENT_ARGS))
+    end
+
+    def token
+      @token ||= login
+    end
+
+    def login
+      response = client.call('LogIn', username, password, language, useragent)
+      if response['status'] != '200 OK'
+        raise LoginFailed.new("Failed to login with #{username} : #{password}. Server return code: #{response['status']}")
+      end
+      response['token']
+    end
+
+    def logout
+      client.call('LogOut', token)
+      @token = nil
+    end
+
+    def check_movie_hash(*hashes)
+      client.call('CheckMovieHash', token, hashes)
+    end
+
+    def search_subtitles(*queries)
+      subs = client.call('SearchSubtitles', token, queries)['data']
+      subs ? subs.map{ |s| Sub.new(s) } : []
+    end
+
+    def search_imdb(options={})
+      query = options.delete(:query)
+      imdb = client.call('SearchMoviesOnIMDB', token, query)['data']
+      imdb.size > 0 ? imdb.map{ |i| OpenStruct.new(:imdbid => i['id'], :title => i['title']) } : []
+    end
+
+    def info
+      client.call('ServerInfo')
+    end
+
+    def get_imdb_movie_details(id)
+      Movie.new(client.call('GetIMDBMovieDetails', token, id)['data'])
+    end
+
+  end
+end

data/lib/opensubtitles/sub.rb

@@ -0,0 +1,55 @@
+require 'uri'
+require 'net/http'
+require 'zlib'
+require 'stringio'
+
+module Opensubtitles
+
+  class Sub
+
+    attr_reader :url, :format, :language, :rating, :user_ranks, :movie_name,
+      :filename, :raw_data, :downloads_count, :bad_reports_count
+
+    def initialize(data)
+      @url = URI.parse(data['SubDownloadLink'])
+      @format = data['SubFormat']
+      @language = Language.from_iso639_2b(data['SubLanguageID'])
+      @rating = data['SubRating'].to_f
+      @user_ranks = data['UserRank']
+      @movie_name = data['MovieName']
+      @filename = data['SubFileName']
+      @downloads_count = data['SubDownloadsCnt'].to_i
+      @bad_reports_count = data['SubBad'].to_i
+      @raw_data = data
+    end
+
+    def <=>(other)
+      rating <=> other.rating
+    end
+
+    # Totaly subjective formula to evaluate subtitle quality
+    # Originaly developed by runa (https://github.com/runa)
+    # https://github.com/byroot/opensubtitles/commit/9d71775#L0R122
+    def score
+      uploader_score * downloads_count.next * (rating + 1) - bad_reports_count / downloads_count.next
+    end
+
+    def uploader_score
+      user_ranks.empty? ? 1 : 2
+    end
+
+    def body
+      @body ||= fetch_body
+    end
+
+    def fetch_body
+      StringIO.open do |buffer|
+        buffer.write(Net::HTTP.get(url))
+        buffer.rewind
+        return Zlib::GzipReader.new(buffer).read
+      end
+    end
+
+  end
+
+end

data/lib/opensubtitles/subtitle_finder.rb

@@ -0,0 +1,30 @@
+module Opensubtitles
+
+  class SubtitleFinder
+
+    def initialize(search_engines, finders, selectors=[])
+      @search_engines = search_engines
+      @finders = finders
+      @selectors = selectors
+    end
+
+    def find_sub_for(movie, language)
+      @search_engines.each do |engine|
+        subs = engine.search_subs_for(movie, language)
+        unless subs.nil?
+          subs = @selectors.inject(subs) do |subs, selector|
+            selector.select(subs, movie)
+          end
+          @finders.each do |finder|
+            sub = finder.chose(subs)
+            return sub if sub
+          end
+        end
+      end
+
+      nil
+    end
+
+  end
+
+end

data/lib/opensubtitles/version.rb

@@ -0,0 +1,3 @@
+module Opensubtitles
+  VERSION = '0.0.1'
+end

data/lib/opensubtitles/xmlrpc_monkey_patch.rb

@@ -0,0 +1,88 @@
+# OpenSubtitle.org return invalid content-length that mek the stdlib xmlrpc client raise
+# This is a dirty monkey patch to workaround this. :'(
+
+module XMLRPC
+  class Client
+    def do_rpc(request, async=false)
+      header = {
+       "User-Agent"     =>  USER_AGENT,
+       "Content-Type"   => "text/xml; charset=utf-8",
+       "Content-Length" => request.bytesize.to_s,
+       "Connection"     => (async ? "close" : "keep-alive")
+      }
+
+      header["Cookie"] = @cookie        if @cookie
+      header.update(@http_header_extra) if @http_header_extra
+
+      if @auth != nil
+        # add authorization header
+        header["Authorization"] = @auth
+      end
+
+      resp = nil
+      @http_last_response = nil
+
+      if async
+        # use a new HTTP object for each call
+        http = net_http(@host, @port, @proxy_host, @proxy_port)
+        http.use_ssl = @use_ssl if @use_ssl
+        http.read_timeout = @timeout
+        http.open_timeout = @timeout
+
+        # post request
+        http.start {
+          resp = http.request_post(@path, request, header)
+        }
+      else
+        # reuse the HTTP object for each call => connection alive is possible
+        # we must start connection explicitely first time so that http.request
+        # does not assume that we don't want keepalive
+        @http.start if not @http.started?
+
+        # post request
+        resp = @http.request_post(@path, request, header)
+      end
+
+      @http_last_response = resp
+
+      data = resp.body
+
+      if resp.code == "401"
+        # Authorization Required
+        raise "Authorization failed.\nHTTP-Error: #{resp.code} #{resp.message}"
+      elsif resp.code[0,1] != "2"
+        raise "HTTP-Error: #{resp.code} #{resp.message}"
+      end
+
+      # assume text/xml on instances where Content-Type header is not set
+      ct_expected = resp["Content-Type"] || 'text/xml'
+      ct = parse_content_type(ct_expected).first
+      if ct != "text/xml"
+        if ct == "text/html"
+          raise "Wrong content-type (received '#{ct}' but expected 'text/xml'): \n#{data}"
+        else
+          raise "Wrong content-type (received '#{ct}' but expected 'text/xml')"
+        end
+      end
+
+      expected = resp["Content-Length"] || "<unknown>"
+      if data.nil? or data.bytesize == 0
+        raise "Wrong size. Was #{data.bytesize}, should be #{expected}"
+      elsif expected != "<unknown>" and expected.to_i != data.bytesize and resp["Transfer-Encoding"].nil?
+        # HACK: here is the monkey patched line
+        # raise "Wrong size. Was #{data.bytesize}, should be #{expected}"
+      end
+
+      set_cookies = resp.get_fields("Set-Cookie")
+      if set_cookies and !set_cookies.empty?
+        require 'webrick/cookie'
+        @cookie = set_cookies.collect do |set_cookie|
+          cookie = WEBrick::Cookie.parse_set_cookie(set_cookie)
+          WEBrick::Cookie.new(cookie.name, cookie.value).to_s
+        end.join("; ")
+      end
+
+      return data
+    end
+  end
+end