storyboard 0.2.3

data/vendor/suby/lib/suby/downloader.rb

@@ -0,0 +1,177 @@
+require 'net/http'
+require 'cgi/util'
+require 'nokogiri'
+require 'xmlrpc/client'
+require 'zlib'
+require 'stringio'
+
+module Suby
+  class Downloader
+    DOWNLOADERS = []
+    def self.inherited(downloader)
+      DOWNLOADERS << downloader
+    end
+
+    attr_reader :show, :season, :episode, :video_data, :file, :lang
+
+    def initialize(file, *args)
+      @file = file
+      @lang = (args.last || 'en').to_sym
+      @video_data = FilenameParser.parse(file)
+      if video_data[:type] == :tvshow
+        @show, @season, @episode = video_data.values_at(:show, :season, :episode)
+      end
+    end
+
+    def support_video_type?
+      self.class::SUBTITLE_TYPES.include? video_data[:type]
+    end
+
+    def to_s
+      self.class.name.sub(/^.+::/, '')
+    end
+
+    def http
+      @http ||= Net::HTTP.new(self.class::SITE).start
+    end
+
+    def xmlrpc
+      @xmlrpc ||= XMLRPC::Client.new(self.class::SITE, self.class::XMLRPC_PATH)
+    end
+
+    def get(path, initheader = {}, parse_response = true)
+      response = http.get(path, initheader)
+      if parse_response
+        unless Net::HTTPSuccess === response
+          raise DownloaderError, "Invalid response for #{path}: #{response}"
+        end
+        response.body
+      else
+        response
+      end
+    end
+
+    def post(path, data = {}, initheader = {})
+      post = Net::HTTP::Post.new(path, initheader)
+      post.form_data = data
+      response = http.request(post)
+      unless Net::HTTPSuccess === response
+        raise DownloaderError, "Invalid response for #{path}(#{data}): " +
+                               response.inspect
+      end
+      response.body
+    end
+
+    def get_redirection(path, initheader = {})
+      response = http.get(path, initheader)
+      location = response['Location']
+      unless (Net::HTTPFound === response or
+              Net::HTTPSuccess === response) and location
+        raise DownloaderError, "Invalid response for #{path}: " +
+              "#{response}: location: #{location.inspect}, #{response.body}"
+      end
+      location
+    end
+
+    def download
+      save extract download_url
+    end
+
+    def subtitles(url_or_response = download_url)
+      if Net::HTTPSuccess === url_or_response
+        url_or_response.body
+      else
+        get(url_or_response)
+      end
+    end
+    
+    def save(contents)
+      sub_name(contents).write 
+    end
+
+    def extract(url_or_response)
+      contents = subtitles(url_or_response)
+      http.finish
+      format = self.class::FORMAT
+      case format
+      when :file
+        # nothing special to do
+      when :gz
+        begin
+          gz = Zlib::GzipReader.new(StringIO.new(contents))
+          contents = gz.read
+        ensure
+          gz.close if gz
+        end
+      when :zip
+        TEMP_ARCHIVE.write contents
+        Suby.extract_sub_from_archive(TEMP_ARCHIVE, format, TEMP_SUBTITLES)
+        contents = TEMP_SUBTITLES.read
+      else
+        raise "unknown subtitles format: #{format}"
+      end
+      encode contents
+    end
+
+    def sub_name(contents)
+      file.sub_ext sub_extension(contents)
+    end
+
+    def sub_extension(contents)
+      if contents[0..10] =~ /1\r?\n/
+        'srt'
+      else
+        'sub'
+      end
+    end
+
+    def imdbid
+      @imdbid ||= begin
+        nfo_file = find_nfo_file
+        convert_to_utf8_from_latin1(nfo_file.read)[%r!imdb\.[^/]+/title/tt(\d+)!i, 1] if nfo_file
+      end
+    end
+
+    def find_nfo_file
+      @file.dir.children.find { |file| file.ext == "nfo" }
+    end
+
+    def convert_to_utf8_from_latin1(content)
+      if content.valid_encoding?
+        content
+      else
+        enc = content.encoding
+        if content.force_encoding("ISO-8859-1").valid_encoding?
+          yield if block_given?
+          content.encode("UTF-8")
+        else
+          # restore original encoding
+          subtitles.force_encoding(enc)
+        end
+      end
+    end
+
+    def success_message
+      "Found"
+    end
+
+    def encode(subtitles)
+      if @lang == :fr
+        convert_to_utf8_from_latin1(subtitles) do
+          def self.success_message
+            "#{super} (transcoded from ISO-8859-1)"
+          end
+        end
+      else
+        subtitles
+      end
+    end
+  end
+end
+
+# Defines downloader order
+%w[
+    opensubtitles
+    tvsubtitles
+    addic7ed
+  ].each { |downloader| require_relative "downloader/#{downloader}" }

data/vendor/suby/lib/suby/filename_parser.rb

@@ -0,0 +1,103 @@
+module Suby
+  module FilenameParser
+    extend self
+
+    # from tvnamer @ ab2c6c, with author's agreement, adapted
+    # See https://github.com/dbr/tvnamer/blob/master/tvnamer/config_defaults.py
+    TVSHOW_PATTERNS = [
+      # foo.s0101
+      /^(?<show>.+?)
+      [ \._\-]
+      [Ss](?<season>[0-9]{2})
+      [\.\- ]?
+      (?<episode>[0-9]{2})
+      [^0-9]*$/x,
+
+      # foo.1x09*
+      /^(?<show>.+?)
+      [ \._\-]
+      \[?
+      (?<season>[0-9]+)
+      [xX]
+      (?<episode>[0-9]+)
+      \]?
+      [^\/]*$/x,
+
+      # foo.s01.e01, foo.s01_e01
+      /^(?<show>.+?)
+      [ \._\-]
+      \[?
+      [Ss](?<season>[0-9]+)[\. _-]?
+      [Ee]?(?<episode>[0-9]+)
+      \]?
+      [^\/]*$/x,
+
+      # foo - [01.09]
+      /^(?<show>.+?)
+      [ \._\-]?
+      \[
+      (?<season>[0-9]+?)
+      [.]
+      (?<episode>[0-9]+?)
+      \]
+      [ \._\-]?
+      [^\/]*$/x,
+
+      # Foo - S2 E 02 - etc
+      /^(?<show>.+?)
+      [ ]?[ \._\-][ ]?
+      [Ss](?<season>[0-9]+)[\.\- ]?
+      [Ee]?[ ]?(?<episode>[0-9]+)
+      [^\/]*$/x,
+
+      # Show - Episode 9999 [S 12 - Ep 131] - etc
+      /(?<show>.+)
+      [ ]-[ ]
+      [Ee]pisode[ ]\d+
+      [ ]
+      \[
+      [sS][ ]?(?<season>\d+)
+      ([ ]|[ ]-[ ]|-)
+      ([eE]|[eE]p)[ ]?(?<episode>\d+)
+      \]
+      .*$/x,
+
+      # foo.103*
+      /^(?<show>.+)
+      [ \._\-]
+      (?<season>[0-9]{1})
+      (?<episode>[0-9]{2})
+      [\._ -][^\/]*$/x,
+    ]
+    MOVIE_PATTERN = /^(?<movie>.*)[.\[( ](?<year>(?:19|20)\d{2})/
+
+    def parse(file)
+      filename = file.basename.to_s
+      if TVSHOW_PATTERNS.find { |pattern| pattern.match(filename) }
+        m = $~
+        { type: :tvshow, show: clean_show_name(m[:show]), season: m[:season].to_i, episode: m[:episode].to_i }
+      elsif m = MOVIE_PATTERN.match(filename)
+        { type: :movie, name: clean_show_name(m[:movie]), year: m[:year].to_i }
+      else
+        { type: :unknown, name: filename }
+      end
+    end
+
+    # from https://github.com/dbr/tvnamer/blob/master/tvnamer/utils.py#L78-95
+    # Cleans up series name by removing any . and _
+    # characters, along with any trailing hyphens.
+    #
+    # Is basically equivalent to replacing all _ and . with a
+    # space, but handles decimal numbers in string.
+    #
+    #   clean_show_name("an.example.1.0.test") # => "an example 1.0 test"
+    #   clean_show_name("an_example_1.0_test") # => "an example 1.0 test"
+    def clean_show_name show
+      show.gsub!(/(?<!\d)[.]|[.](?!\d)/, ' ')
+      show.tr!('_', ' ')
+      show.chomp!('-')
+      show.strip!
+      show
+    end
+  end
+end

data/vendor/suby/lib/suby/interface.rb

@@ -0,0 +1,17 @@
+require 'term/ansicolor'
+
+module Suby
+  module Interface
+    def success message
+      puts Term::ANSIColor.green message
+    end
+
+    def failure message
+       puts Term::ANSIColor.blue message
+    end
+
+    def error message
+       puts Term::ANSIColor.red message
+    end
+  end
+end

data/vendor/suby/lib/suby/movie_hasher.rb

@@ -0,0 +1,31 @@
+module Suby
+  # from http://trac.opensubtitles.org/projects/opensubtitles/wiki/HashSourceCodes
+  module MovieHasher
+
+    CHUNK_SIZE = 64 * 1024 # in bytes
+    MASK64 = 0xffffffffffffffff # 2^64 - 1
+
+    def self.compute_hash(file)
+      filesize = file.size
+      hash = filesize
+
+      # Read 64 kbytes, divide up into 64 bits and add each
+      # to hash. Do for beginning and end of file.
+      file.open('rb') do |f|
+        # Q = unsigned long long = 64 bit
+        f.read(CHUNK_SIZE).unpack("Q*").each do |n|
+          hash = (hash + n) & MASK64
+        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) & MASK64
+        end
+      end
+
+      "%016x" % hash
+    end
+  end
+end

data/vendor/suby/lib/suby.rb

@@ -0,0 +1,89 @@
+require 'path'
+require 'zip/zip'
+require 'mime/types'
+
+Path.require_tree 'suby', except: %w[downloader/]
+
+module Suby
+  NotFoundError = Class.new StandardError
+  DownloaderError = Class.new StandardError
+
+  SUB_EXTENSIONS = %w[srt sub]
+  TMPDIR = Path.tmpdir
+  TEMP_ARCHIVE = TMPDIR / 'archive'
+  TEMP_SUBTITLES = TMPDIR / 'subtitles'
+
+  class << self
+    include Interface
+
+    def download_subtitles(files, options = {})
+      Zip.options[:on_exists_proc] = options[:force]
+      files.each { |file|
+        file = Path(file)
+        if file.dir?
+          download_subtitles(file.children, options)
+        elsif SUB_EXTENSIONS.include?(file.ext)
+          # ignore already downloaded subtitles
+        elsif !options[:force] and SUB_EXTENSIONS.any? { |ext| f = file.sub_ext(ext) and f.exist? and !f.empty? }
+          puts "Skipping: #{file}"
+        elsif !file.exist? or video?(file)
+          download_subtitles_for_file(file, options)
+        end
+      }
+    ensure
+      TMPDIR.rm_rf
+    end
+
+    def video?(file)
+      MIME::Types.type_for(file.path).any? { |type| type.media_type == "video" }
+    end
+
+    def download_subtitles_for_file(file, options)
+      begin
+        puts file
+        success = Downloader::DOWNLOADERS.find { |downloader_class|
+          try_downloader(downloader_class.new(file, options[:lang]))
+        }
+        error "\nNo downloader could find subtitles for #{file}" unless success
+      rescue
+        error "\nThe download of the subtitles failed for #{file}:"
+        error "#{$!.class}: #{$!.message}"
+        $stderr.puts $!.backtrace
+      end
+    end
+
+    def try_downloader(downloader)
+      return false unless downloader.support_video_type?
+      begin
+        print "  #{downloader.to_s.ljust(20)}"
+        downloader.download
+      rescue Suby::NotFoundError => error
+        failure "Failed: #{error.message}"
+        false
+      rescue Suby::DownloaderError => error
+        error "Error: #{error.message}"
+        false
+      else
+        success downloader.success_message
+        true
+      end
+    end
+
+    def extract_sub_from_archive(archive, format, file)
+      case format
+      when :zip
+        Zip::ZipFile.open(archive.to_s) { |zip|
+          sub = zip.entries.find { |entry|
+            entry.to_s =~ /\.#{Regexp.union SUB_EXTENSIONS}$/
+          }
+          raise "no subtitles in #{archive}" unless sub
+          sub.extract(file.to_s)
+        }
+      else
+        raise "unknown archive type (#{archive})"
+      end
+    ensure
+      archive.unlink if archive.exist?
+    end
+  end
+end

data/vendor/suby/spec/mock_http.rb

@@ -0,0 +1,22 @@
+class Suby::Downloader
+  caches = {}
+  [:get, :post, :get_redirection].each { |meth|
+    original_method = instance_method(meth)
+    remove_method meth
+    define_method(meth) { |*args|
+      file = 'spec/fixtures/' + self.class::SITE.downcase + '.marshal'
+      caches[file] ||= File.exist?(file) ? Marshal.load(IO.read(file)) : {}
+      data = caches[file]
+
+      if data[args]
+        data[args]
+      else
+        puts "doing the real request: #{meth}(#{args * ', '})"
+        value = original_method.bind(self).call(*args)
+        data[args] = value
+        File.write(file, Marshal.dump(data))
+        value
+      end
+    }
+  }
+end

data/vendor/suby/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'rspec'
+require_relative '../lib/suby'
+require_relative 'mock_http'

data/vendor/suby/spec/suby/downloader/addict7ed_spec.rb

@@ -0,0 +1,28 @@
+require_relative '../../spec_helper'
+
+describe Suby::Downloader::Addic7ed do
+  file = Path('The Glee Project 01x03.avi')
+  downloader = Suby::Downloader::Addic7ed.new file
+
+  it 'finds the right subtitles' do
+    begin
+      downloader.subtitles[0..100].should include "Ellis, best first kiss?"
+    rescue Suby::NotFoundError => e
+      if e.message == "download exceeded"
+        pending e.message
+      else
+        raise e
+      end
+    end
+  end
+
+  it 'fails gently when the show or the episode does not exist' do
+    d = Suby::Downloader::Addic7ed.new(Path('Not Existing Show 1x1.mkv'))
+    -> { d.download_url }.should raise_error(Suby::NotFoundError, "show/season/episode not found")
+  end
+
+  it 'fails gently when there is no subtitles available' do
+    d = Suby::Downloader::Addic7ed.new(file, :es)
+    -> { p d.download_url }.should raise_error(Suby::NotFoundError, "no subtitles available")
+  end
+end

data/vendor/suby/spec/suby/downloader/opensubtitles_spec.rb

@@ -0,0 +1,33 @@
+require_relative '../../spec_helper'
+
+describe Suby::Downloader::OpenSubtitles do
+  file = Path("breaking.bad.s05e04.hdtv.x264-fqm.mp4")
+  downloader = Suby::Downloader::OpenSubtitles.new file
+  correct_query = [{ moviehash: "709b9ff887cf987d", moviebytesize: "308412149", sublanguageid: "eng" }]
+  wrong_query = correct_query.first.merge({ sublanguageid: "wrong_language" })
+
+  it 'finds the right subtitles' do
+    response = downloader.search_subtitles(correct_query)['data']
+    response.should_not be_false
+    response.first['MovieName'].should == '"Breaking Bad" Fifty-One'
+  end
+
+  it 'finds the right download link' do
+    url = downloader.download_url
+    url.should match(%r{http(s)?://.*opensubtitles.org/en/download/.*})
+  end
+
+  it "doesn't find anything for bad query" do
+    response = downloader.search_subtitles(wrong_query)['data']
+    response.should be_false
+  end
+
+  it "gets right token" do
+    downloader.token.should match(/\A[a-z0-9]{26}\z/)
+  end
+
+  it 'fails gently when there is no subtitles available' do
+    d = Suby::Downloader::OpenSubtitles.new(Path("Not Existing Show 1x1.mkv"), :eawdad)
+    -> { d.download_url }.should raise_error(Suby::NotFoundError, "no subtitles available")
+  end
+end

data/vendor/suby/spec/suby/downloader/tvsubtitles_spec.rb

@@ -0,0 +1,50 @@
+require_relative '../../spec_helper'
+
+describe Suby::Downloader::TVSubtitles do
+  file = Path('How I Met Your Mother 3x9 - Slapsgiving.mkv')
+  downloader = Suby::Downloader::TVSubtitles.new(file)
+  downloader_fr = Suby::Downloader::TVSubtitles.new(file, :fr)
+
+  it 'finds the right show url' do
+    downloader.show_url.should == '/tvshow-110.html'
+  end
+
+  it 'finds the right season url' do
+    downloader.season_url.should == '/tvshow-110-3.html'
+  end
+
+  it 'finds the right episode url' do
+    downloader.episode_url.should == '/episode-7517-en.html'
+    downloader_fr.episode_url.should == '/episode-7517-fr.html'
+  end
+
+  it 'finds the right subtitles url' do
+    downloader.subtitles_url.should == '/subtitle-9339.html'
+    downloader_fr.subtitles_url.should == '/subtitle-31249.html'
+  end
+
+  it 'finds the right download url' do
+    downloader.download_url.should == '/files/How%20I%20Met%20Your%20Mother_3x09_en.zip'
+    downloader_fr.download_url.should == '/files/How%20I%20Met%20Your%20Mother_3x09_fr.zip'
+  end
+
+  it 'fails gently when the show does not exist' do
+    d = Suby::Downloader::TVSubtitles.new(Path('Not Existing Show 1x1.mkv'))
+    -> { d.show_url }.should raise_error(Suby::NotFoundError, "show not found")
+  end
+
+  it 'fails gently when the season does not exist' do
+    d = Suby::Downloader::TVSubtitles.new(Path('How I Met Your Mother 99x1.mkv'))
+    -> { d.episode_url }.should raise_error(Suby::NotFoundError, "season not found")
+  end
+
+  it 'fails gently when the episode does not exist' do
+    d = Suby::Downloader::TVSubtitles.new(Path('How I Met Your Mother 3x99.mkv'))
+    -> { d.episode_url }.should raise_error(Suby::NotFoundError, "episode not found")
+  end
+
+  it 'fails gently when there is no subtitles available' do
+    d = Suby::Downloader::TVSubtitles.new(Path('Batman: The Animated Series 1x03.mkv'))
+    -> { d.subtitles_url }.should raise_error(Suby::NotFoundError, "no subtitles available")
+  end
+end

data/vendor/suby/spec/suby/downloader_spec.rb

@@ -0,0 +1,11 @@
+require_relative '../spec_helper'
+
+describe Suby::Downloader do
+  downloader = Suby::Downloader.new Path('How I Met Your Mother 3x9 - Slapsgiving.mkv')
+  it 'guess the right type of subtitles from the contents' do
+    downloader.sub_extension("1\r\n00").should == 'srt'
+    downloader.sub_extension("\xEF\xBB\xBF1\r\n00:00:14,397").should == 'srt'
+    downloader.sub_extension("\xEF\xBB\xBF1\r\n00:00:14,397").should == 'srt'
+    downloader.sub_extension("{346}{417}informa").should == 'sub'
+  end
+end

data/vendor/suby/spec/suby/filename_parser_spec.rb

@@ -0,0 +1,66 @@
+require_relative '../spec_helper'
+
+describe Suby::Downloader do
+  show = 'How I Met Your Mother'
+  season, episode = 3, 9
+  title = 'Slapsgiving'
+  ext = 'mkv'
+  dot_show = show.tr(' ', '.')
+  und_show = show.tr(' ', '_')
+  movie_name = "Somemovie.2002.720p.BluRay"
+  unknown_name = "crf-hp4"
+
+  context "cleans correctly the show name" do
+    {
+      dot_show => show,
+      und_show => show,
+      "an.example.1.0.test" => "an example 1.0 test",
+      "an_example_1.0_test" => "an example 1.0 test",
+      "an_3.0.1.example_1.0_test" => "an 3.0.1 example 1.0 test",
+    }.each_pair { |raw_show, true_show|
+      it raw_show do
+        # dup because a literal String is frozen and no point to keep the raw show
+        Suby::FilenameParser.clean_show_name(raw_show.dup).should == true_show
+      end
+    }
+  end
+
+  context "parse correctly the file name" do
+    [
+      {
+        examples:
+        [
+            "#{show} #{season}x#{episode}",
+            "#{show} #{season}x#{"%.2d" % episode}",
+            "#{show} #{season}x#{episode} - #{title}",
+            "#{show} #{season}x#{"%.2d" % episode} - #{title}",
+            "#{dot_show}.s0309",
+            "#{dot_show}.3x09",
+            "#{dot_show}.s03.e09",
+            "#{und_show}.s03_e09",
+            "#{show} - [03.09]",
+            "#{show} - S3 E 09",
+            "#{show} - Episode 9999 [S 3 - Ep 9]",
+            "#{show} - Episode 9999 [S 3 - Ep 9] - ",
+            "#{dot_show}.309",
+        ],
+        expected: { type: :tvshow, show: show, season: season, episode: episode }
+      },
+      {
+        examples: [movie_name],
+        expected: { type: :movie, name: "Somemovie", year: 2002 }
+      },
+      {
+        examples: [unknown_name],
+        expected: { type: :unknown, name: "#{unknown_name}.#{ext}"}
+      }
+    ].each do |type|
+      type[:examples].each do |filename|
+        it filename do
+          file = Path(filename).add_ext(ext)
+          Suby::FilenameParser.parse(file).should == type[:expected]
+        end
+      end
+    end
+  end
+end

data/vendor/suby/spec/suby_spec.rb

@@ -0,0 +1,27 @@
+require_relative 'spec_helper'
+require 'tmpdir'
+require 'digest/md5'
+
+describe Suby do
+  file = 'How I Met Your Mother 3x9 - Slapsgiving.mkv'
+  srt  = 'How I Met Your Mother 3x9 - Slapsgiving.srt'
+
+  it 'works :D', full: true do
+    Dir.mktmpdir do |dir|
+      suby = File.expand_path('../../bin/suby', __FILE__)
+      Dir.chdir(dir) do
+        system suby, file
+        Digest::MD5.hexdigest(File.read(srt)).should == '7c4b89452782c20c6086ba5c1f4e9d74'
+      end
+    end
+  end
+
+  it 'can detect videos' do
+    %w[avi mp4 mkv].each { |ext|
+      Suby.should be_a_video(Path("file").add_ext(ext))
+    }
+    %w[txt srt sub].each { |ext|
+      Suby.should_not be_a_video(Path("file").add_ext(ext))
+    }
+  end
+end

data/vendor/suby/suby.gemspec

@@ -0,0 +1,20 @@
+Gem::Specification.new do |s|
+  s.name = 'suby'
+  s.summary = "Subtitles' downloader"
+  s.description = "Find and download subtitles"
+  s.author = 'eregon'
+  s.email = 'eregontp@gmail.com'
+  s.homepage = 'https://github.com/eregon/suby'
+
+  s.files = Dir['bin/*', 'lib/**/*.rb', '.gitignore', 'README.md', 'suby.gemspec']
+  s.executables = ['suby']
+
+  s.required_ruby_version = '>= 1.9.2'
+  s.add_dependency 'path', '>= 1.3.0'
+  s.add_dependency 'nokogiri'
+  s.add_dependency 'rubyzip'
+  s.add_dependency 'term-ansicolor'
+  s.add_dependency 'mime-types', '>= 1.19'
+
+  s.version = '0.4.0'
+end