rmd 0.0.1

data/lib/rmd/nct/getter/key_from_page.rb

@@ -0,0 +1,50 @@
+require 'rmd/nct/getter/base'
+
+module RMD
+  module NCT
+    module Getter
+      class KeyFromPage < Base
+
+        def fetch
+          if key && element
+            @data_link = element.text.strip
+          else
+            @errors = "The page does not contain the key."
+          end
+        end
+
+        private
+
+        def uncached_key
+          page.search('script').each do |element|
+            if match_data = /NCTNowPlaying.intFlashPlayer\("flashPlayer", "song", "(.+)"\)\;/.match(element.text)
+              return match_data.to_a.last
+            end
+          end
+
+          nil
+        end
+
+        def new_link
+          "http://www.nhaccuatui.com/flash/xml?key1=#{key}"
+        end
+
+        def page
+          @page ||= agent.get(url)
+        end
+
+        def new_page
+          @new_page ||= agent.get(new_link)
+        end
+
+        def response
+          @response ||= Nokogiri::XML(new_page.body)
+        end
+
+        def element
+          @element ||= response.at_xpath('.//tracklist//location')
+        end
+      end
+    end
+  end
+end

data/lib/rmd/nct/getter/key_from_url.rb

@@ -0,0 +1,44 @@
+require 'rmd/nct/getter/base'
+
+module RMD
+  module NCT
+    module Getter
+      class KeyFromUrl < Base
+        ROOT_URL = 'http://www.nhaccuatui.com/download/song'
+
+        def fetch
+          if key
+            if response['error_message'] == 'Success'
+              @data_link = response['data']['stream_url']
+            else
+              @errors = "#{response['error_message']}: #{new_link}"
+            end
+          else
+            @errors = "The url does not contain the key."
+          end
+        end
+
+        private
+
+        def response
+          @response ||= JSON.parse(page.body)
+        end
+
+        def uncached_key
+          uri = URI.parse(url)
+          if data = /\.(\S+)\./.match(uri.path)
+            data.to_a.last
+          end
+        end
+
+        def new_link
+          "#{ROOT_URL}/#{key}"
+        end
+
+        def page
+          @page ||= agent.get(new_link)
+        end
+      end
+    end
+  end
+end

data/lib/rmd/nct/playlist.rb

@@ -0,0 +1,63 @@
+require 'mechanize'
+
+module RMD
+  module NCT
+    class Playlist
+      attr_reader :errors, :link, :songs
+
+      def initialize(link)
+        @link = link
+      end
+
+      def fetch
+        if song_elements.count > 0
+          @errors = []
+          progress_bar = ProgressBar.create(
+            starting_at: 0,
+            total: song_elements.count,
+            format: '%c / %C Songs %B %p%%'
+          )
+
+          @songs = song_elements.inject([]) do |result, element|
+            link = element.attr('href')
+            song = RMD::NCT::Song.new(link)
+            song.fetch
+            if song.success?
+              result << song.data_link
+            else
+              @errors << song.errors
+            end
+
+            progress_bar.increment
+            result
+          end
+        else
+          @songs = []
+          @errors = ['Can not get song lists from this playlist page.']
+        end
+      end
+
+      def success?
+        !!songs && songs.count > 0
+      end
+
+      private
+
+      def song_css
+        '.item_content .name_song'
+      end
+
+      def song_elements
+        @song_element ||= page.search(song_css)
+      end
+
+      def page
+        @page ||= agent.get(link)
+      end
+
+      def agent
+        agent ||= Mechanize.new
+      end
+    end
+  end
+end

data/lib/rmd/nct/song.rb

@@ -0,0 +1,36 @@
+require 'rmd/nct/getter/key_from_page'
+require 'rmd/nct/getter/key_from_url'
+
+module RMD
+  module NCT
+    class Song
+      attr_reader :errors, :link, :data_link
+
+      def initialize(link)
+        @link = link
+      end
+
+      def fetch
+        getters.each do |getter|
+          getter.fetch
+          @data_link = getter.data_link
+          @errors = getter.errors
+          break unless @errors
+        end
+      end
+
+      def success?
+        !!data_link
+      end
+
+      private
+
+      def getters
+        [
+          RMD::NCT::Getter::KeyFromUrl.new(link),
+          RMD::NCT::Getter::KeyFromPage.new(link)
+        ]
+      end
+    end
+  end
+end

data/lib/rmd/processor.rb

@@ -0,0 +1,44 @@
+require 'rmd/downloader'
+require 'rmd/factory'
+require 'ruby-progressbar'
+
+module RMD
+  class Processor
+    attr_reader :link
+
+    def initialize(link)
+      @link = link
+    end
+
+    def process
+      puts "Start processing #{link}...".green
+      playlist = RMD::Factory.build(link)
+      playlist.fetch
+
+      if playlist.success?
+        playlist.songs.each do |song|
+          download(song)
+        end
+      end
+
+      playlist.errors.each do |error|
+        puts error.red
+      end
+    end
+
+    def self.process(link)
+      begin
+        new(link).process
+      rescue => e
+        puts e.message.red
+        puts 'Errors! Can not continue!'.red
+      end
+    end
+
+    private
+
+    def download(data_link)
+      RMD::Downloader.download(data_link)
+    end
+  end
+end

data/lib/rmd/song_playlist_adapter.rb

@@ -0,0 +1,20 @@
+module RMD
+  class SongPlaylistAdapter
+    extend Forwardable
+
+    attr_reader :song
+    def_delegators :song, :fetch, :success?
+
+    def initialize(song)
+      @song = song
+    end
+
+    def songs
+      [song.data_link].compact
+    end
+
+    def errors
+      [song.errors].compact
+    end
+  end
+end

data/lib/rmd/version.rb

@@ -0,0 +1,3 @@
+module Rmd
+  VERSION = "0.0.1"
+end

data/rmd.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rmd/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rmd"
+  spec.version       = Rmd::VERSION
+  spec.authors       = ["Hieu Nguyen"]
+  spec.email         = ["hieuk09@gmail.com"]
+  spec.summary       = %q{RMD: Ruby Music Dowloader}
+  spec.description   = %q{RMD: a music downloader written in pure ruby.}
+  spec.homepage      = "https://github.com/hieuk09/rmd"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = 'rmd'
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'thor', '~> 0.19'
+  spec.add_dependency 'mechanize', '~> 2.7'
+  spec.add_dependency 'ruby-progressbar', '~> 1.7'
+  spec.add_dependency 'colorize', '~> 0.7'
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rspec", '~> 3.1'
+  spec.add_development_dependency "webmock", '~> 1.20'
+  spec.add_development_dependency "vcr", '~> 2.9'
+  spec.add_development_dependency "byebug", '~> 3.5'
+end

data/spec/rmd/downloader_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe RMD::Downloader do
+  describe '.download' do
+    let(:link) { 'www.example/xyz/abc.mp3' }
+    let(:downloader) { instance_double('RMD::Downloader') }
+
+    it 'downloads' do
+      expect(described_class).to receive(:new).with(link).and_return(downloader)
+      expect(downloader).to receive(:download)
+      described_class.download(link)
+    end
+  end
+
+  describe '#download' do
+    let(:downloader) { described_class.new(link) }
+    let(:link) { 'http://db.gamefaqs.com/portable/3ds/file/fire_emblem_awakening_shop.txt' }
+    let(:file_name) { 'fire_emblem_awakening_shop.txt' }
+    let(:content_length) { body.length }
+    let(:file_path) { File.expand_path("../../../#{file_name}", __FILE__) }
+    let(:result) { File.read(file_path) }
+
+    it 'downloads' do
+      VCR.use_cassette("song download") do
+        expect {
+          downloader.download
+        }.to output("\e[0;32;49m#{file_name}\e[0m\n").to_stdout
+        expect(File.exists?(file_path)).to eq true
+      end
+      File.delete(file_path)
+    end
+  end
+end

data/spec/rmd/factory_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe RMD::Factory do
+  describe '.build' do
+    let(:factory) { double('RMD::Factory') }
+    let(:link) { 'link' }
+
+    it 'builds adapter' do
+      expect(described_class).to receive(:new).with(link).and_return(factory)
+      expect(factory).to receive(:build)
+      described_class.build(link)
+    end
+  end
+
+  describe '#build' do
+    let(:factory) { described_class.new(link) }
+    subject { factory.build }
+
+    context 'when link belongs to nhaccuatui website' do
+      context 'when link is song link' do
+        let(:link) { 'www.nhaccuatui/bai-hat/song.mp3' }
+        it { is_expected.to be_a(RMD::SongPlaylistAdapter) }
+      end
+
+      context 'when link is playlist link' do
+        let(:link) { 'www.nhaccuatui/playlist/bang-kieu' }
+        it { is_expected.to be_a(RMD::NCT::Playlist) }
+      end
+    end
+  end
+end

data/spec/rmd/nct/getter/key_from_page_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+
+describe RMD::NCT::Getter::KeyFromPage do
+  let(:url) { 'url' }
+  let(:getter) { described_class.new(url) }
+
+  describe '#fetch' do
+    let(:element) { double('Element', text: data_link) }
+    let(:data_link) { 'data_link' }
+    let(:key) { 'key' }
+    let(:errors) { 'The page does not contain the key.' }
+
+    before do
+      allow(getter).to receive(:key).and_return(key)
+      allow(getter).to receive(:element).and_return(element)
+      getter.fetch
+    end
+
+    context 'when key is not present' do
+      let(:key) { nil }
+
+      it 'returns errors' do
+        expect(getter.data_link).to eq nil
+        expect(getter.errors).to eq errors
+      end
+    end
+
+    context 'when element is not present' do
+      let(:element) { nil }
+
+      it 'returns errors' do
+        expect(getter.data_link).to eq nil
+        expect(getter.errors).to eq errors
+      end
+    end
+
+    context 'otherwise' do
+      it 'gets data' do
+        expect(getter.data_link).to eq data_link
+        expect(getter.errors).to eq nil
+      end
+    end
+  end
+
+  describe '#response' do
+    let(:body) { '<body>abc</body>' }
+    let(:new_page) { double('Page', body: body) }
+    let(:response) { getter.send(:response).child }
+
+    before do
+      expect(getter).to receive(:new_page).and_return(new_page)
+    end
+
+    it 'parse the response from the page' do
+      expect(response.name).to eq 'body'
+      expect(response.text).to eq 'abc'
+    end
+  end
+
+  describe '#key' do
+    let(:page) { double('Page') }
+    let(:elements) { [element] }
+    let(:element) { double('Element', text: text) }
+    subject { getter.send(:key) }
+
+    before do
+      expect(getter).to receive(:page).and_return(page)
+      expect(page).to receive(:search).with('script').and_return(elements)
+    end
+
+    context 'when match data exists' do
+      let(:text) { 'NCTNowPlaying.intFlashPlayer("flashPlayer", "song", "key");' }
+      it { is_expected.to eq 'key' }
+    end
+
+    context 'when match data is not exists' do
+      let(:text) { 'NCTNowPlaying.initFlashPlayer();' }
+      it { is_expected.to eq nil }
+    end
+  end
+
+  describe '#element' do
+    let(:response) { Nokogiri::XML(xml) }
+
+    before do
+      expect(getter).to receive(:response).and_return(response)
+    end
+
+    context 'when the path exists' do
+      let(:xml) { '<tracklist><location>abc</location></tracklist>' }
+      let(:subject) { getter.send(:element).text }
+      it { is_expected.to eq 'abc' }
+    end
+
+    context 'when the path is not exists' do
+      let(:xml) { '<location>abc</location>' }
+      subject { getter.send(:element) }
+      it { is_expected.to eq nil }
+    end
+  end
+
+  describe '#new_link' do
+    let(:key) { 'key' }
+    subject { getter.send(:new_link) }
+
+    before do
+      expect(getter).to receive(:key).and_return(key)
+    end
+
+    it { is_expected.to eq 'http://www.nhaccuatui.com/flash/xml?key1=key' }
+  end
+
+  describe '#page' do
+    let(:agent) { instance_double('Mechanize') }
+    let(:page) { double('Page') }
+    subject { getter.send(:page) }
+
+    before do
+      expect(getter).to receive(:agent).and_return(agent)
+      expect(agent).to receive(:get).with(url).and_return(page)
+    end
+
+    it { is_expected.to eq page }
+  end
+
+  describe '#new_page' do
+    let(:new_link) { 'new_link' }
+    let(:agent) { instance_double('Mechanize') }
+    let(:page) { double('Page') }
+    subject { getter.send(:new_page) }
+
+    before do
+      expect(getter).to receive(:new_link).and_return(new_link)
+      expect(getter).to receive(:agent).and_return(agent)
+      expect(agent).to receive(:get).with(new_link).and_return(page)
+    end
+
+    it { is_expected.to eq page }
+  end
+end