groove-dl 0.1.0

data/lib/groove-dl/widgets/search/bar.rb

@@ -0,0 +1,67 @@
+# -*- coding: utf-8 -*-
+module GrooveDl
+  # Widgets components
+  module Widgets
+    # Search section
+    module Search
+      # Search bar
+      class Bar < Gtk::Box
+        attr_reader :type, :query
+
+        ##
+        # Initialize widgets
+        #
+        # @param [Grooveshark::Client] client Grooveshark client
+        # @param [Gtk::Window] window Gtk app
+        #
+        def load(client, window)
+          search_box = Gtk::Box.new(:horizontal, 6)
+
+          search_bar = Gtk::Entry.new
+          search_bar.set_name('search_bar')
+          search_bar.text = 'CruciAGoT'
+          search_box.pack_start(search_bar,
+                                expand: true,
+                                fill: true,
+                                padding: 10)
+
+          search_type = Gtk::ComboBoxText.new
+          search_type.set_name('search_type')
+          search_type.append_text 'Playlists'
+          search_type.append_text 'Songs'
+          search_type.active = 0
+
+          search_box.pack_start(search_type,
+                                expand: false,
+                                fill: true,
+                                padding: 5)
+
+          button = Gtk::Button.new(label: 'Search', stock_id: Gtk::Stock::FIND)
+          button.signal_connect('released') do
+            @type = search_type.active_text
+            @query = search_bar.text
+            next if @type.empty? || @query.empty?
+            search = client.request('getResultsFromSearch',
+                                    type: @type,
+                                    query: @query)
+            results = search['result'].map do |data|
+              next Grooveshark::Song.new data if type == 'Songs'
+              data
+            end if search.key?('result')
+
+            window.find_by_name('search_list').create_model(results)
+          end
+
+          search_box.pack_start(button,
+                                expand: false,
+                                fill: false,
+                                padding: 10)
+
+          pack_start(search_box,
+                     expand: false,
+                     padding: 10)
+        end
+      end
+    end
+  end
+end

data/lib/groove-dl/widgets/search/list.rb

@@ -0,0 +1,146 @@
+# -*- coding: utf-8 -*-
+module GrooveDl
+  # Widgets components
+  module Widgets
+    # Search section
+    module Search
+      # Search list tree
+      class List < Gtk::Box
+        attr_reader :data
+        attr_reader :store
+        attr_reader :selection
+
+        COLUMN_FIXED,
+        COLUMN_ID,
+        COLUMN_NAME,
+        COLUMN_AUTHOR,
+        COLUMN_SONG = *(0..5).to_a
+
+        ##
+        # Initialize widgets
+        #
+        # @param [Grooveshark::Client] client Grooveshark client
+        # @param [Gtk::Window] window Gtk app
+        #
+        def load(_client, _window)
+          set_name('search_list')
+
+          @selection = {}
+          sw = Gtk::ScrolledWindow.new
+          sw.shadow_type = Gtk::ShadowType::ETCHED_IN
+          sw.set_policy(Gtk::PolicyType::AUTOMATIC, Gtk::PolicyType::AUTOMATIC)
+          pack_start(sw, expand: true, fill: true, padding: 0)
+
+          @store = Gtk::ListStore.new(TrueClass,
+                                      Integer,
+                                      String,
+                                      String,
+                                      String)
+          create_model
+          treeview = Gtk::TreeView.new(@store)
+          treeview.rules_hint = true
+          treeview.search_column = COLUMN_SONG
+
+          sw.add(treeview)
+
+          add_columns(treeview)
+        end
+
+        ##
+        # Create line in the list store
+        #
+        # @param [Array] data Data stored
+        #
+        def create_model(data = [])
+          @store.clear
+          @data = {}
+          data.each do |element|
+            iter = @store.append
+            iter[COLUMN_FIXED] = false
+            if element.is_a?(Grooveshark::Song)
+              @data[element.id.to_i] = element
+              iter[COLUMN_ID] = element.id.to_i
+              iter[COLUMN_NAME] = element.name
+              iter[COLUMN_AUTHOR] = element.artist
+              iter[COLUMN_SONG] = element.album
+            else
+              @data[element['playlist_id'].to_i] = element
+              iter[COLUMN_ID] = element['playlist_id'].to_i
+              iter[COLUMN_NAME] = element['name']
+              iter[COLUMN_AUTHOR] = element['f_name']
+              iter[COLUMN_SONG] = element['num_songs']
+            end
+          end
+        end
+
+        ##
+        # Add columns on the treeview element
+        #
+        # @param [Gtk::Treeview] treeview Treeview
+        #
+        def add_columns(treeview)
+          renderer = Gtk::CellRendererToggle.new
+          renderer.signal_connect('toggled') do |_cell, path|
+            fixed_toggled(treeview.model, path)
+          end
+
+          column = Gtk::TreeViewColumn.new('X',
+                                           renderer,
+                                           'active' => COLUMN_FIXED)
+          column.sizing = Gtk::TreeViewColumn::Sizing::FIXED
+          column.fixed_width = 30
+          treeview.append_column(column)
+
+          renderer = Gtk::CellRendererText.new
+          column = Gtk::TreeViewColumn.new('Id',
+                                           renderer,
+                                           'text' => COLUMN_ID)
+          column.set_sort_column_id(COLUMN_ID)
+          column.sizing = Gtk::TreeViewColumn::Sizing::FIXED
+          column.fixed_width = 70
+          treeview.append_column(column)
+
+          renderer = Gtk::CellRendererText.new
+          column = Gtk::TreeViewColumn.new('Name',
+                                           renderer,
+                                           'text' => COLUMN_NAME)
+          column.set_sort_column_id(COLUMN_NAME)
+          column.fixed_width = 400
+          treeview.append_column(column)
+
+          renderer = Gtk::CellRendererText.new
+          column = Gtk::TreeViewColumn.new('Author',
+                                           renderer,
+                                           'text' => COLUMN_AUTHOR)
+          column.set_sort_column_id(COLUMN_AUTHOR)
+          column.fixed_width = 200
+          treeview.append_column(column)
+
+          renderer = Gtk::CellRendererText.new
+          column = Gtk::TreeViewColumn.new('Other data',
+                                           renderer,
+                                           'text' => COLUMN_SONG)
+          column.set_sort_column_id(COLUMN_SONG)
+          column.fixed_width = 100
+          treeview.append_column(column)
+        end
+
+        ##
+        # Fixed toggle button
+        #
+        # @param [Gtk::ListStore] model List store
+        # @param [String] path_str Path to row
+        #
+        def fixed_toggled(model, path_str)
+          path = Gtk::TreePath.new(path_str)
+          iter = model.get_iter(path)
+          fixed = iter[COLUMN_FIXED]
+          fixed ^= 1
+          iter[COLUMN_FIXED] = fixed
+          @selection[iter[COLUMN_ID]] = @data[iter[COLUMN_ID]] if fixed
+          @selection.delete(iter[COLUMN_ID]) unless fixed
+        end
+      end
+    end
+  end
+end

data/spec/groove-dl/cli_spec.rb

@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+require 'groove-dl/cli'
+require 'slop'
+
+# Groove Dl tests
+module GrooveDl
+  # CLI tests
+  module CLI
+    describe 'CLI' do
+      it 'should return options' do
+        options = CLI.options
+        expect(options).to be_a(::Slop)
+        expect(options.config[:strict]).to be_truthy
+        expect(options.config[:banner])
+          .to eq('Usage: groove-dl [COMMAND] [OPTIONS]')
+        expect(options.to_s)
+          .to match(/-v, --version(\s+)Shows the current version/)
+        expect(options.to_s)
+          .to match(/-h, --help(\s+)Display this help message./)
+
+        version = options.fetch_option(:v)
+        expect(version.short).to eq('v')
+        expect(version.long).to eq('version')
+        expect { version.call }.to output(/Groove-dl v.* on ruby/).to_stdout
+      end
+
+      it 'should retrieve version information' do
+        expect(CLI.version_information).to eq(
+          "Groove-dl v#{VERSION} on #{RUBY_DESCRIPTION}"
+        )
+      end
+
+      it 'should download playlist' do
+        allow(Grooveshark::Client).to receive(:new).and_return(true)
+        downloader = double
+        allow(downloader).to receive(:playlist).with(1).and_return(true)
+        allow(Downloader).to receive(:new).and_return(downloader)
+        expect(CLI.options.parse %w( -p 1)).to eq(['-p', '1'])
+      end
+
+      it 'should do nothing if v option is passed' do
+        expect(CLI.options).to receive(:puts).with(/Groove-dl v.* on ruby/)
+          .and_return(nil)
+        expect(CLI.options.parse %w( -v)).to eq(['-v'])
+      end
+    end
+  end
+end

data/spec/groove-dl/displayer_spec.rb

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+require 'grooveshark'
+require 'terminal-table'
+require 'fakefs/spec_helpers'
+require 'groove-dl/displayer'
+
+# Groove Dl tests
+module GrooveDl
+  # Downloader test
+  describe 'Displayer' do
+    include FakeFS::SpecHelpers
+
+    before(:each) do
+    end
+
+    it 'should initialize' do
+      song = Grooveshark::Song.new('song_id' =>  1,
+                                   'name' => 'test',
+                                   'artist_name' => 'got')
+      displayer = Displayer.new([song], 'Songs')
+      expect(displayer.type).to eq('Songs')
+      expect(displayer.result.first).to be_a(Grooveshark::Song)
+    end
+
+    it 'should render songs' do
+      song = Grooveshark::Song.new('song_id' =>  1,
+                                   'name' => 'test',
+                                   'artist_name' => 'got')
+      displayer = Displayer.new([song], 'Songs')
+
+      str = '+----+-------+--------+------+
+|           Songs            |
++----+-------+--------+------+
+| Id | Album | Artist | Song |
++----+-------+--------+------+
+| 1  |       | got    | test |
++----+-------+--------+------+'
+      allow(displayer).to receive(:puts)
+        .with(str).and_return(nil)
+      expect(displayer.render).to be_nil
+    end
+
+    it 'should render songs' do
+      playlist = { 'playlist_id' => 1,
+                   'name' => 'Someting',
+                   'f_name' => 'GoT',
+                   'num_songs' => 1 }
+      displayer = Displayer.new([playlist], 'Playlists')
+
+      str = '+----+----------+--------+----------+
+|             Playlists             |
++----+----------+--------+----------+
+| Id | Nam      | Author | NumSongs |
++----+----------+--------+----------+
+| 1  | Someting | GoT    | 1        |
++----+----------+--------+----------+'
+      allow(displayer).to receive(:puts)
+        .with(str).and_return(nil)
+      expect(displayer.render).to be_nil
+    end
+  end
+end

data/spec/groove-dl/downloader_spec.rb

@@ -0,0 +1,188 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+require 'grooveshark'
+require 'ruby-progressbar'
+require 'fakefs/spec_helpers'
+require 'groove-dl/downloader'
+require 'groove-dl/errors'
+require 'slop'
+
+# Groove Dl tests
+module GrooveDl
+  # Downloader test
+  describe 'Downloader' do
+    include FakeFS::SpecHelpers
+
+    before(:each) do
+      @client = double
+      @downloader = Downloader.new(@client, {})
+    end
+
+    it 'should do nothing if playlist not found' do
+      allow(@client).to receive(:request).and_return({})
+      expect(@downloader.playlist(1)).to be_falsy
+    end
+
+    it 'should do nothing if queue is empty' do
+      expect(@downloader.download_queue).to be_falsy
+    end
+
+    it 'should download playlist' do
+      allow(@client).to receive(:request)
+        .and_return('songs' => [{ 'song_id' =>  1,
+                                  'name' => 'test',
+                                  'artist_name' => 'got',
+                                  'album_name' => 'ruby' }])
+      allow(@client).to receive(:get_stream_auth_by_songid)
+        .with(1).and_return({})
+      allow(@client).to receive(:get_song_url_by_id)
+        .with(1).and_return('http://test/stream?key=something')
+
+      allow(RestClient::Request).to receive(:execute)
+        .and_return(true)
+
+      expect(@downloader.playlist('1'))
+        .to eq(skipped: 0, downloaded: 0)
+    end
+
+    it 'should download song' do
+      allow(@client).to receive(:get_stream_auth_by_songid)
+        .with(1).and_return({})
+      allow(@client).to receive(:get_song_url_by_id)
+        .with(1).and_return('http://test/stream?key=something')
+
+      allow(RestClient::Request).to receive(:execute)
+        .and_return(true)
+
+      expect(@downloader.song(1))
+        .to eq(skipped: 0, downloaded: 0)
+    end
+
+    it 'should process response in cli mode' do
+      Dir.mkdir('/tmp')
+      pbar = double
+      allow(pbar).to receive(:progress).and_return(pbar)
+      allow(pbar).to receive(:+).and_return(0)
+      allow(pbar).to receive(:progress=).and_return(0)
+      allow(pbar).to receive(:finish).and_return(true)
+      allow(ProgressBar).to receive(:create)
+        .with(title: 'got-test.mp3', format: '%a |%b>>%i| %p%% %t', total: 1)
+        .and_return(pbar)
+      response = double
+      allow(response).to receive(:[])
+        .with('content-length').and_return('1')
+      allow(response).to receive(:read_body)
+        .and_yield('something')
+        .and_yield('nested')
+
+      expect(@downloader.process_cli_response('/tmp/got-test.mp3')
+               .call(response))
+        .to eq(1)
+
+      expect(File.read('/tmp/got-test.mp3')).to eq('somethingnested')
+    end
+
+    it 'should process response in cli mode and does not download twice' do
+      Dir.mkdir('/tmp')
+      response = double
+      allow(response).to receive(:[])
+        .with('content-length').and_return('15')
+      allow(response).to receive(:read_body)
+        .and_yield('something')
+        .and_yield('nested')
+
+      File.open('/tmp/got-test.mp3', 'w') do |f|
+        f.write('somethingnested')
+      end
+
+      expect do
+        @downloader.process_cli_response('/tmp/got-test.mp3')
+          .call(response)
+      end.to raise_error(Errors::AlreadyDownloaded,
+                         '/tmp/got-test.mp3 already downloaded')
+    end
+
+    it 'should process response in gui mode' do
+      Dir.mkdir('/tmp')
+      stub_const('Widgets::Download::List::Queue::COLUMN_PATH', 0)
+      stub_const('Widgets::Download::List::Queue::COLUMN_PGBAR_VALUE', 1)
+      stub_const('Widgets::Download::List::Queue::COLUMN_PGBAR_TEXT', 2)
+      iter = []
+      iter[0] = '/tmp/got-test.mp3'
+      response = double
+      allow(response).to receive(:[])
+        .with('content-length').and_return('15')
+      allow(response).to receive(:read_body)
+        .and_yield('something')
+        .and_yield('nested')
+
+      expect(@downloader.process_gui_response(iter)
+               .call(response))
+        .to eq('Complete')
+
+      expect(iter[1]).to eq(100)
+      expect(iter[2]).to eq('Complete')
+
+      expect(File.read('/tmp/got-test.mp3')).to eq('somethingnested')
+    end
+
+    it 'should process response in gui mode and does not download twice' do
+      Dir.mkdir('/tmp')
+      stub_const('Widgets::Download::List::Queue::COLUMN_PATH', 0)
+      stub_const('Widgets::Download::List::Queue::COLUMN_PGBAR_VALUE', 1)
+      stub_const('Widgets::Download::List::Queue::COLUMN_PGBAR_TEXT', 2)
+      iter = []
+      iter[0] = '/tmp/got-test.mp3'
+      response = double
+      allow(response).to receive(:[])
+        .with('content-length').and_return('15')
+      allow(response).to receive(:read_body)
+        .and_yield('something')
+        .and_yield('nested')
+
+      File.open('/tmp/got-test.mp3', 'w') do |f|
+        f.write('somethingnested')
+      end
+
+      expect do
+        @downloader.process_gui_response(iter)
+          .call(response)
+      end.to raise_error(Errors::AlreadyDownloaded,
+                         '/tmp/got-test.mp3 already downloaded')
+
+      expect(iter[1]).to eq(100)
+      expect(iter[2]).to eq('Complete')
+
+      expect(File.read('/tmp/got-test.mp3')).to eq('somethingnested')
+    end
+
+    it 'should download in gui mode' do
+      @downloader.type = 'gui'
+      Dir.mkdir('/tmp')
+      stub_const('Widgets::Download::List::Queue::COLUMN_PATH', 0)
+      stub_const('Widgets::Download::List::Queue::COLUMN_PGBAR_VALUE', 1)
+      stub_const('Widgets::Download::List::Queue::COLUMN_PGBAR_TEXT', 2)
+      iter = []
+      iter[0] = '/tmp/got-test.mp3'
+
+      allow(@client).to receive(:get_stream_auth_by_songid)
+        .with(1).and_return({})
+      allow(@client).to receive(:get_song_url_by_id)
+        .with(1).and_return('http://test/stream?key=something')
+
+      head_return = double
+      allow(head_return).to receive(:headers)
+        .and_return(content_length: nil)
+
+      allow(RestClient).to receive(:head)
+        .and_return(head_return)
+
+      allow(RestClient::Request).to receive(:execute)
+        .and_return(true)
+
+      song = Grooveshark::Song.new('song_id' => 1)
+      expect(@downloader.download(song, iter))
+        .to eq(true)
+    end
+  end
+end