download_tv 2.6.5 → 2.6.7

data/lib/download_tv/myepisodes.rb

@@ -5,32 +5,65 @@ module DownloadTV
   # API wrapper for MyEpisodes
   class MyEpisodes
     def initialize(user, save_cookie)
-      @agent = Mechanize.new
-      @agent.user_agent = DownloadTV::USER_AGENT
       @user = user
       @save_cookie = save_cookie
       @cookie_path = File.join(ENV['HOME'], '.config', 'download_tv', 'cookie')
+      agent.user_agent = DownloadTV::USER_AGENT
+      login
+    end
+
+    def get_shows_since(last, include_tomorrow: false)
+      page = agent.get 'https://www.myepisodes.com/ajax/service.php?mode=view_privatelist'
+      shows = page.parser.css('tr.past')
+      shows = filter_newer_shows(shows, last)
+      shows.concat(page.parser.css('tr.today')) if include_tomorrow
+      build_show_strings(shows)
+    end
+
+    private
+
+    def agent
+      @agent ||= Mechanize.new
     end
 
     def login
+      logged_in_with_cookie = load_cookie
+      manual_login unless logged_in_with_cookie
+    end
+
+    def manual_login
       pass = prompt_user_data
-      page = @agent.get 'https://www.myepisodes.com/login.php'
+      page = agent.get 'https://www.myepisodes.com/login.php'
 
       login_form = page.forms[1]
       login_form.username = @user
       login_form.password = pass
 
-      page = @agent.submit(login_form, login_form.buttons.first)
+      page = agent.submit(login_form, login_form.buttons.first)
 
       raise InvalidLoginError if page.filename == 'login.php'
 
-      save_cookie if @save_cookie
+      store_cookie if @save_cookie
+    end
+
+    ##
+    # If there is a cookie file, tries to log in using it
+    # returns the result of the operation (true/false)
+    def load_cookie
+      if File.exist? @cookie_path
+        agent.cookie_jar.load @cookie_path
+        return true if logged_in?
+
+        puts 'The cookie is invalid/has expired.'
+      else
+        puts 'Cookie file not found'
+      end
 
-      @agent
+      false
     end
 
     def prompt_user_data
-      if !@user || @user == ''
+      if @user.nil? || @user.empty?
         print 'Enter your MyEpisodes username: '
         @user = $stdin.gets.chomp
       end
@@ -41,47 +74,21 @@ module DownloadTV
       pass
     end
 
-    def load_cookie
-      if File.exist? @cookie_path
-        @agent.cookie_jar.load @cookie_path
-        return @agent if logged_in?
-
-        puts 'The cookie is invalid/has expired.'
-      else
-        puts 'Cookie file not found'
-      end
-
-      login
-    end
-
     def logged_in?
-      page = @agent.get 'https://www.myepisodes.com/login.php'
+      page = agent.get 'https://www.myepisodes.com/login.php'
       page.links[1].text != 'Register'
     end
 
-    def save_cookie
-      @agent.cookie_jar.save(@cookie_path, session: true)
-      @agent
-    end
-
-    def get_shows_since(last)
-      page = @agent.get 'https://www.myepisodes.com/ajax/service.php?mode=view_privatelist'
-      shows = page.parser.css('tr.past')
-      shows = filter_newer_shows(shows, last)
-      build_show_strings(shows)
-    end
-
-    def today_shows
-      page = @agent.get 'https://www.myepisodes.com/ajax/service.php?mode=view_privatelist'
-      shows = page.parser.css('tr.today')
-      build_show_strings(shows)
+    def store_cookie
+      agent.cookie_jar.save(@cookie_path, session: true)
     end
 
     # Only keep the shows that have aired since the given date
     def filter_newer_shows(shows, date)
       shows.select do |i|
         airdate = i.css('td.date')[0].text
-        Date.parse(airdate) >= date
+        viewed_checkbox = i.css('td.status input').last
+        Date.parse(airdate) >= date && viewed_checkbox&.attribute('checked').nil?
       end
     end
 

data/lib/download_tv/torrent.rb

@@ -4,26 +4,49 @@ module DownloadTV
   ##
   # Class in charge of managing the link grabbers
   class Torrent
-    attr_reader :g_instances, :tries
+    class << self
+      def grabbers
+        %w[TorrentAPI Torrentz Eztv]
+      end
 
-    def grabbers
-      %w[TorrentAPI Torrentz Eztv]
+      def healthcheck
+        grabbers.each do |g|
+          grabber = (DownloadTV.const_get g).new
+          puts "#{g}: #{grabber.online? ? 'online' : 'offline'}"
+        end
+      end
     end
 
     def initialize(default_grabber = nil)
-      g_names = grabbers
-
-      # Silently ignores bad names
-      found_default = g_names.find_index(default_grabber)
-      g_names.rotate! found_default if found_default
-
-      @g_instances = g_names.map { |g| (DownloadTV.const_get g).new }
+      @g_instances = self.class.grabbers\
+        .rotate(self.class.grabbers.find_index(default_grabber) || 0)
+        .map { |g| (DownloadTV.const_get g).new }
       reset_tries
 
-      check_grabber_online
+      remove_grabber_if_offline
     end
 
-    def check_grabber_online
+    def get_links(show)
+      @g_instances.first.get_links(show)
+    rescue NoTorrentsError
+      if @tries.positive?
+        change_grabbers
+        retry
+      end
+      # We're out of grabbers to try
+      puts "No torrents found for #{show}"
+      []
+    ensure
+      reset_grabbers_order
+    end
+
+    private
+
+    ##
+    # This method removes the grabber from the instances list if it is not online
+    # It will repeat until it finds an online grabber, or  exit the application
+    # if there are none
+    def remove_grabber_if_offline
       if @g_instances.empty?
         warn 'There are no available grabbers.'
         exit 1
@@ -34,27 +57,13 @@ module DownloadTV
       warn "Problem accessing #{@g_instances.first.class.name}"
       @tries -= 1
       @g_instances.shift # Removes first element
-      check_grabber_online
+      remove_grabber_if_offline
     end
 
     def change_grabbers
       @tries -= 1
       @g_instances.rotate!
-      check_grabber_online
-    end
-
-    def get_links(show)
-      @g_instances.first.get_links(show)
-    rescue NoTorrentsError
-      if @tries.positive?
-        change_grabbers
-        retry
-      end
-      # We're out of grabbers to try
-      puts "No torrents found for #{show}"
-      []
-    ensure
-      reset_grabbers_order
+      remove_grabber_if_offline
     end
 
     def reset_tries

data/lib/download_tv/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DownloadTV
-  VERSION = '2.6.5'
+  VERSION = '2.6.7'
 end

data/lib/download_tv.rb

@@ -14,7 +14,6 @@ require 'download_tv/torrent'
 require 'download_tv/filterer'
 require 'download_tv/myepisodes'
 require 'download_tv/linkgrabber'
-require 'download_tv/subtitles'
 
 module DownloadTV
   USER_AGENT = "DownloadTV #{DownloadTV::VERSION}"

data/spec/download_tv/configuration_spec.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+describe DownloadTV::Configuration do
+  let(:raw_config) { double('raw_config') }
+  let(:parsed_config) { { version: DownloadTV::VERSION, pending: [] } }
+  let(:opts) { {} }
+  subject { described_class.new(opts) }
+
+  before :each do
+    allow(File).to receive(:exist?).and_return true
+    allow(File).to receive(:read).and_return raw_config
+    allow(JSON).to receive(:parse).and_return parsed_config
+  end
+
+  describe '#[] and #[]=' do
+    it 'will set and get values of the underlying hash' do
+      subject[:test] = :any
+      expect(subject[:test]).to eq(:any)
+    end
+  end
+
+  describe '#initialize' do
+    context 'when the config file exists' do
+      context 'when options are given' do
+        let(:opts) { { myepisodes_user: 'test', pending: [1], ignored: ['aAAa'] } }
+        it 'will apply them to the final config' do
+          expect(subject[:myepisodes_user]).to eq opts[:myepisodes_user]
+          expect(subject[:pending]).to eq opts[:pending]
+        end
+
+        it 'will downcase strings in :ignored' do
+          expect(subject[:ignored].first).to eq opts[:ignored].first.downcase
+        end
+      end
+    end
+
+    context 'when the config file does not exist' do
+      before :each do
+        allow(File).to receive(:exist?).and_return false
+        allow(FileUtils).to receive(:mkdir_p)
+        allow_any_instance_of(described_class).to receive(:change_configuration)
+        allow_any_instance_of(described_class).to receive(:serialize)
+      end
+
+      context 'when options are given' do
+        let(:opts) { { myepisodes_user: 'test' } }
+
+        it 'will override the other values' do
+          expect(subject[:myepisodes_user]).to eq opts[:myepisodes_user]
+        end
+      end
+    end
+  end
+
+  describe '#change_configuration' do
+    let(:myepisodes_user) { 'myep' }
+    let(:cookies) { 'n' }
+    let(:ignored) { 'ignored1,ignored2' }
+
+    before :each do
+      allow(File).to receive(:exist?).and_return false
+      allow(FileUtils).to receive(:mkdir_p)
+      allow_any_instance_of(described_class).to receive(:serialize)
+      allow($stdin).to receive(:gets).and_return(myepisodes_user, cookies, ignored, '', '')
+    end
+
+    it 'will create a new config with the given and the default values' do
+      expect(subject[:myepisodes_user]).to eq myepisodes_user
+      expect(subject[:cookie]).to be false
+      expect(subject[:auto]).to be true
+      expect(subject[:ignored].size).to eq 2
+      expect(subject[:date]).to eq(Date.today - 1)
+      expect(subject[:filters]).not_to be_nil
+      expect(subject[:version]).not_to be_nil
+      expect(subject[:pending]).not_to be_nil
+      expect(subject[:grabber]).not_to be_nil
+    end
+  end
+
+  describe '#serialize' do
+    let(:parsed_config) { { version: DownloadTV::VERSION, pending: [1, 1, 2] } }
+
+    before :each do
+      allow(File).to receive(:write).and_return nil
+    end
+
+    it 'will remove duplicates from :pending' do
+      subject.serialize
+      expect(subject[:pending].size).to eq 2
+    end
+
+    it 'will write to a file' do
+      expect(File).to receive(:write)
+      subject.serialize
+    end
+
+    context 'when a path is given in the options' do
+      let(:opts) { { path: '/tmp/test' } }
+      it 'will write to a file in our given path' do
+        config = double('config')
+        expect(JSON).to receive(:generate).and_return(config)
+        expect(File).to receive(:write).with(opts[:path], config)
+        subject.serialize
+      end
+    end
+  end
+
+  describe '#to_s' do
+    it 'will form a string with each (key, value) pair in a new line' do
+      expected = "version: #{DownloadTV::VERSION}\n"\
+        "pending: []\n"
+      expect(subject.to_s).to eq expected
+    end
+  end
+
+  describe '#clear_pending' do
+    it 'will clear :pending and call serialize' do
+      subject[:pending] << double
+      expect(subject).to receive(:serialize)
+      expect(subject[:pending].size).to eq 1
+      subject.clear_pending
+      expect(subject[:pending].size).to eq 0
+    end
+  end
+
+  describe '#queue_pending' do
+    it 'will add an item to :pending and serialize' do
+      expect(subject).to receive(:serialize)
+      expect(subject[:pending].size).to eq 0
+      subject.queue_pending(double)
+      expect(subject[:pending].size).to eq 1
+    end
+  end
+
+  context 'breaking changes:' do
+    let(:version) { nil }
+    let(:parsed_config) do
+      {
+        version: version
+      }
+    end
+
+    before :each do
+      stub_const('DownloadTV::VERSION', '2.1.10')
+      allow(File).to receive(:exist?).and_return true
+      allow(File).to receive(:read).and_return raw_config
+      allow(JSON).to receive(:parse).and_return parsed_config
+    end
+
+    describe 'when the config does not have a version' do
+      it 'will trigger a config update' do
+        expect_any_instance_of(described_class).to receive(:change_configuration).once.and_return nil
+        subject
+      end
+    end
+
+    describe 'when the app version is newer (patch)' do
+      let(:version) { '2.1.9' }
+      it 'will NOT trigger a config update' do
+        expect_any_instance_of(described_class).not_to receive(:change_configuration)
+        subject
+      end
+    end
+
+    describe 'when the app version is the same' do
+      let(:version) { '2.1.10' }
+      it 'will NOT trigger a config update' do
+        expect_any_instance_of(described_class).not_to receive(:change_configuration)
+        subject
+      end
+    end
+
+    describe 'when the app version is newer (minor)' do
+      let(:version) { '2.0.19' }
+
+      it 'will trigger a config update' do
+        expect_any_instance_of(described_class).to receive(:change_configuration).once.and_return nil
+        subject
+      end
+    end
+
+    describe 'when the app version is newer (major)' do
+      let(:version) { '1.20.999' }
+
+      it 'will trigger a config update' do
+        expect_any_instance_of(described_class).to receive(:change_configuration).once.and_return nil
+        subject
+      end
+    end
+
+    describe 'when the app version is older (any)' do
+      let(:version) { '2.1.11' }
+      it 'will trigger a config update' do
+        expect_any_instance_of(described_class).to receive(:change_configuration).once.and_return nil
+        subject
+      end
+    end
+  end
+end

data/spec/download_tv/filterer_spec.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+describe DownloadTV::Filterer do
+  let(:excludes) { [] }
+  let(:includes) { [] }
+  let(:filters_config) { { excludes: excludes, includes: includes } }
+
+  subject { described_class.new(filters_config) }
+
+  describe '#filter' do
+    let(:test_data) do
+      [
+        'Test 12',
+        'Test 10',
+        'Exclude'
+      ]
+    end
+
+    context 'when there are no filters' do
+      it 'will return the given list' do
+        expect(subject.filter(test_data)).to eq test_data
+      end
+    end
+
+    context 'when there are exclude filters' do
+      describe 'when there is only one entry not matching (one filter)' do
+        let(:excludes) { ['TEST'] }
+        it 'will return it' do
+          filtered = subject.filter(test_data)
+          expect(filtered.size).to eq 1
+          expect(filtered.first).to eq 'Exclude'
+        end
+      end
+
+      describe 'when there is only one entry not matching (multiple filter)' do
+        let(:excludes) { ['2', '0'] }
+        it 'will return it' do
+          filtered = subject.filter(test_data)
+          expect(filtered.size).to eq 1
+          expect(filtered.first).to eq 'Exclude'
+        end
+      end
+
+      describe 'when only one filter matches' do
+        let(:excludes) { ['0'] }
+        it 'will not return that element' do
+          filtered = subject.filter(test_data)
+          expect(filtered.size).to eq 2
+          expect(filtered.include?('Test 10')).to be false
+        end
+      end
+
+      describe 'when no entries match' do
+        let(:excludes) { ['zzzz'] }
+        it 'will return the original' do
+          filtered = subject.filter(test_data)
+          expect(filtered).to eq test_data
+        end
+      end
+
+      describe 'when all entries match (one filter)' do
+        let(:excludes) { ['E'] }
+        it 'will return the original' do
+          filtered = subject.filter(test_data)
+          expect(filtered).to eq test_data
+        end
+      end
+
+      describe 'when all entries match (more filters)' do
+        let(:excludes) { ['TEST', 'EXCLUDE'] }
+        it 'will only apply filters until there would be no values left' do
+          filtered = subject.filter(test_data)
+          expect(filtered.size).to eq 1
+          expect(filtered.first).to eq 'Exclude'
+        end
+      end
+    end
+
+    context 'when there are include filters' do
+      let(:includes) { ['TEST'] }
+      it 'will filter out entries not matching' do
+        filtered = subject.filter(test_data)
+        expect(filtered.size).to eq 2
+        expect(filtered.include?('Exclude')).to be false
+      end
+    end
+
+    context 'when there are both types of filters' do
+      let(:excludes) { ['EXCLUDE'] }
+      let(:includes) { ['EXCLUDE'] }
+
+      it 'will apply "includes" filters first' do
+        filtered = subject.filter(test_data)
+        expect(filtered.size).to eq 1
+        expect(filtered.first).to eq 'Exclude'
+      end
+
+      describe 'if the filters are not capitalised' do
+        let(:excludes) { ['exclude'] }
+        let(:includes) { ['test'] }
+        it 'will not apply the filter successfully' do
+          expect(subject.filter(test_data)).to eq test_data
+        end
+      end
+    end
+  end
+end

data/spec/download_tv/linkgrabber_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+describe DownloadTV::LinkGrabber do
+  # TODO: Write specs for the individual grabbers (see #4)
+  # grabbers = DownloadTV::Torrent.grabbers
+  # instances = grabbers.map { |g| (DownloadTV.const_get g).new }
+
+  # instances.each do |grabber|
+  #   describe grabber do
+  #   end
+  # end
+
+  it "raises an error if the instance doesn't implement get_links" do
+    expect { DownloadTV::LinkGrabber.new(double).get_links(double) }.to raise_error(NotImplementedError)
+  end
+end

data/spec/download_tv/myepisodes_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+describe DownloadTV::MyEpisodes do
+  let(:save_cookie) { true }
+  let(:page) { double('page') }
+  let(:agent) { double('agent', :user_agent= => nil, get: page) }
+  let(:cookie_jar) { double('cookie_jar') }
+  subject { described_class.new('user', true) }
+
+  before :each do
+    allow(Mechanize).to receive(:new).and_return agent
+    allow(agent).to receive(:cookie_jar).and_return cookie_jar
+    allow(cookie_jar).to receive(:load)
+    allow(cookie_jar).to receive(:save)
+  end
+
+  describe '#initialize' do
+    context 'when cookie does not load' do
+      it 'will execute a user/password login' do
+        allow_any_instance_of(described_class).to receive(:load_cookie).and_return false
+        expect_any_instance_of(described_class).to receive(:manual_login).once.and_return nil
+        subject
+      end
+    end
+
+    context 'when using a valid cookie' do
+      it 'will log in via cookie' do
+        allow_any_instance_of(described_class).to receive(:load_cookie).and_return true
+        expect_any_instance_of(described_class).not_to receive(:manual_login)
+        subject
+      end
+    end
+  end
+
+  describe '#get_shows_since' do
+    # TODO
+  end
+end