cultome_player 2.0.0

data/lib/cultome_player/version.rb

@@ -0,0 +1,3 @@
+module CultomePlayer
+  VERSION = "2.0.0"
+end

data/spec/cultome_player/command/processor_spec.rb

@@ -0,0 +1,168 @@
+require 'spec_helper'
+
+describe CultomePlayer::Command::Processor do
+  let(:t){ TestClass.new }
+
+  context '#read_command' do
+  end
+
+  context '#get_tokens' do
+    it 'respond to get_tokens method' do
+      t.should respond_to :get_tokens
+    end
+
+    it 'split literals' do
+      t.get_tokens("uno dos").should eq ["uno", "dos"]
+    end
+
+    it 'split strings' do
+      t.get_tokens("'uno dos' 'tres cuatro'").should eq ["uno dos", "tres cuatro"]
+    end
+
+    it 'split numbers' do
+      t.get_tokens("1 2 3").should eq ["1", "2", "3"]
+    end
+
+    it 'split objects' do
+      t.get_tokens("@uno @dos").should eq ["@uno", "@dos"]
+    end
+
+    it 'split paths' do
+      t.get_tokens("/home/mio '/home/tuyo/con espacio'").should eq ["/home/mio", "/home/tuyo/con espacio"]
+    end
+
+    it 'split criteria' do
+      t.get_tokens("uno:dos tres:'cuatro cinco'").should eq ["uno:dos", "tres:cuatro cinco"]
+    end
+
+    it 'raise an error if unclosed string is present' do
+      expect { t.get_tokens("uno 'dos") }.to raise_error
+    end
+  end
+
+  context '#identify_tokens' do
+    it 'identify object' do
+      t.identify_tokens(["@uno"]).should eq [{type: :object, value: "uno"}]
+    end
+
+    it 'identify criteria' do
+      t.identify_tokens(["uno:dos"]).should eq [{type: :criteria, criteria: "uno", value: "dos"}]
+    end
+
+    it 'identify path' do
+      t.identify_tokens(["/home/mio"]).should eq [{type: :path, value: "/home/mio"}]
+      t.identify_tokens(["~/music"]).should eq [{type: :path, value: "~/music"}]
+    end
+
+    it 'identify number' do
+      t.identify_tokens(["1"]).should eq [{type: :number, value: "1"}]
+    end
+
+    it 'identify literal' do
+      t.identify_tokens(["uno"]).should eq [{type: :literal, value: "uno"}]
+    end
+
+    it 'identify as unknown token that dont recognize' do
+      t.identify_tokens(["@uno dos"]).should eq [{type: :unknown, value: "@uno dos"}]
+      t.identify_tokens(["uno dos:tres"]).should eq [{type: :unknown, value: "uno dos:tres"}]
+      t.identify_tokens(["uno/dos"]).should eq [{type: :unknown, value: "uno/dos"}]
+    end
+  end
+
+  context '#validate_command' do
+    it 'validate a command without parameters' do
+      t.validate_command(:command, [{type: :literal, value: "stop"}]).should be_true
+    end
+
+    it 'validate a command with one parameter' do
+      t.validate_command(:command, [{type: :literal, value: "play"}, {type: :literal, value: "uno"}]).should be_true
+    end
+
+    it 'validate a command with more than one parameter' do
+      t.validate_command(:command, [{type: :literal, value: "play"}, {type: :number, value: "1"}, {type: :object, value: "dos"}, {type: :criteria, criteria: "tres", value: "cuatro"}]).should be_true
+    end
+
+    it 'detect invalid command' do
+      expect{
+        t.validate_command(:command, [{type: :unknown, value: "uno1"}])
+      }.to raise_error("invalid command:invalid command")
+    end
+
+    it 'detect invalid command format' do
+      expect{
+        t.validate_command(:command, [{type: :number, value: "1"}])
+      }.to raise_error("invalid command:invalid command")
+    end
+  end
+
+  context 'parse user command' do
+    it 'respond to parse method' do
+      t.should respond_to :parse
+    end
+
+    it 'returns a command object' do
+      t.parse("next").should be_instance_of CultomePlayer::Objects::Command
+    end
+
+    it 'returns a command even when defined as plugin' do
+      t.parse("help").should be_instance_of CultomePlayer::Objects::Command
+    end
+
+    it 'set the action and parameter' do
+      cmd = t.parse("enqueue uno 'dos' tres:cuatro")
+
+      cmd.action.should eq "enqueue"
+      cmd.parameters.should have(3).items
+    end
+
+    it 'basic command' do
+      cmd = t.parse("prev")
+      cmd.action.should eq "prev"
+      cmd.should have(0).parameters
+    end
+
+    it 'with one parameter' do
+      cmd = t.parse("shuffle on")
+      cmd.action.should eq "shuffle"
+      cmd.should have(1).parameters
+    end
+
+    it 'with many parameter' do
+      cmd = t.parse("play uno @dos tes:cuatro")
+      cmd.action.should eq "play"
+      cmd.should have(3).parameters
+    end
+
+    context 'detect parameter type' do
+      it 'type literal' do
+        cmd = t.parse("search uno")
+        cmd.should have(1).parameters
+        cmd.params(:literal).should have(1).item
+      end
+
+      it 'type number' do
+        cmd = t.parse("enqueue 1 2")
+        cmd.should have(2).parameters
+        cmd.params(:number).should have(2).item
+      end
+
+      it 'type object' do
+        cmd = t.parse("show @uno")
+        cmd.should have(1).parameters
+        cmd.params(:object).should have(1).item
+      end
+
+      it 'type path' do
+        cmd = t.parse("connect /home/mio/music => main")
+        cmd.should have(3).parameters
+        cmd.params(:path).should have(1).item
+      end
+
+      it 'type criteria' do
+        cmd = t.parse("play uno:dos")
+        cmd.should have(1).parameters
+        cmd.params(:criteria).should have(1).item
+      end
+    end
+  end
+end

data/spec/cultome_player/command/reader_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe CultomePlayer::Command::Reader do
+  let(:t){ TestClass.new }
+
+  context 'autocomplete' do
+    it 'actions' do
+      Readline.stub(:line_buffer){ "pl" }
+      t.send(:completion_proc).call("pl").should eq ["play "]
+    end
+
+    it 'path parameters' do
+      Readline.stub(:line_buffer){ "play /hom" }
+      t.send(:completion_proc).call("/hom").should eq ["/home/"]
+    end
+
+    it 'object parameters' do
+      Readline.stub(:line_buffer){ "play @art" }
+      t.send(:completion_proc).call("@art").should eq ["@artist"]
+    end
+  end
+
+  context 'show probable' do
+    it 'actions' do
+      Readline.stub(:line_buffer){ "p" }
+      t.send(:completion_proc).call("p").should eq ["play ",  "pause ", "prev "]
+    end
+
+    it 'parameter types' do
+      Readline.stub(:line_buffer){ "play " }
+      t.send(:completion_proc).call("").should eq ["<literal>", "<number>", "<criteria>", "<object>", " "]
+    end
+
+    it 'paths' do
+      Readline.stub(:line_buffer){ "play /home/" }
+      opcs = t.send(:completion_proc).call("/home/")
+      opcs.each{|opc| opc.should start_with "/home/" }
+    end
+
+    it 'objects' do
+      Readline.stub(:line_buffer){ "play @a" }
+      t.send(:completion_proc).call("@a").should eq ["@artist", "@album"]
+    end
+  end
+end

data/spec/cultome_player/cultome_player_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe CultomePlayer do
+	let(:t){ TestClass.new(:rspec) }
+
+	it 'executes built int commands' do
+		t.execute('search way').should_not be_nil
+	end
+
+	it 'executes plugins' do
+		t.execute('help').should_not be_nil
+	end
+
+	it 'contains usage instrucctions' do
+		t.should respond_to(:usage_cultome_player)
+	end
+end

data/spec/cultome_player/environment_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe CultomePlayer::Environment do
+  let(:t){ TestClass.new(nil) }
+
+  it 'prepare environment' do
+    t.prepare_environment(:rspec)
+    t.env_config.should_not be_empty
+  end
+
+  context 'with no environment loaded' do
+    it 'raise exception when using mplayer_pipe' do
+      expect{ t.mplayer_pipe }.to raise_error('environment problem:environment information not loaded')
+    end
+
+    it 'raise exception when using db_adapter' do
+      expect{ t.db_adapter }.to raise_error('environment problem:environment information not loaded')
+    end
+
+    it 'raise exception when using db_file' do
+      expect{ t.db_file }.to raise_error('environment problem:environment information not loaded')
+    end
+    it 'raise exception when using db_log_file' do
+      expect{ t.db_log_file }.to raise_error('environment problem:environment information not loaded')
+    end
+
+    it 'raise exception when using file_types' do
+      expect{ t.file_types }.to raise_error('environment problem:environment information not loaded')
+    end
+
+    it 'raise exception when using config_file' do
+      expect{ t.config_file }.to raise_error('environment problem:environment information not loaded')
+    end
+  end
+
+  context 'with environment loaded' do
+    before :each do
+      t.prepare_environment(:rspec)
+    end
+
+    it 'load the db_adapter' do
+      t.db_adapter.should eq 'sqlite3'
+    end
+
+    it 'load the mplayer_pipe' do
+      t.mplayer_pipe.should end_with 'spec/mpctr'
+    end
+
+    it 'load the db_file' do
+      t.db_file.should end_with 'spec/db.dat'
+    end
+
+    it 'load the db_log_file' do
+      t.db_log_file.should end_with 'spec/db.log'
+    end
+
+    it 'load the file_types' do
+      t.file_types.should eq 'mp3'
+    end
+
+    it 'load the config_file' do
+      t.config_file.should end_with 'spec/config.yml'
+    end
+  end
+end

data/spec/cultome_player/events_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe CultomePlayer::Events do
+  let(:t){ TestClass.new }
+  let(:l1){ double(:listener1, :on_my_event => "OK 1!" ) }
+  let(:l2){ double(:listener2, :on_my_event => "OK 2!" ) }
+
+  it 'register event listeners' do
+    t.listeners.should be_empty
+    t.register_listener(:my_event, l1)
+    t.listeners.should have(1).item
+  end
+
+  it 'callback listeners on event' do
+    l1.should_receive(:on_my_event).with("DATA")
+    l2.should_receive(:on_my_event).with("DATA")
+    t.register_listener(:my_event, l1)
+    t.register_listener(:my_event, l2)
+    r = t.emit_event(:my_event, "DATA")
+    r.should eq ["OK 1!", "OK 2!"]
+  end
+end

data/spec/cultome_player/media_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe CultomePlayer::Media do
+  let(:t){ TestClass.new }
+
+  describe 'parse mp3 information' do
+    before :each do
+      @info = t.extract_from_mp3("#{test_folder}/uno/uno.mp3")
+    end
+
+    it 'read name' do
+      @info[:name].should_not be_nil
+      @info[:name].should_not be_empty
+    end
+
+    it 'read album' do
+      @info[:album].should_not be_nil
+      @info[:album].should_not be_empty
+    end
+
+    it 'read genre' do
+      @info[:genre].should_not be_nil
+      @info[:genre].should_not be_empty
+    end
+
+    it 'read track' do
+      @info[:track].should_not be_nil
+      @info[:track].should > 0
+    end
+
+    it 'read year' do
+      @info[:year].should_not be_nil
+      @info[:year].should > 0
+    end
+
+    it 'read duration' do
+      @info[:duration].should_not be_nil
+      @info[:duration].should > 0
+    end
+  end
+end

data/spec/cultome_player/player/adapter/mpg123_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe CultomePlayer::Player::Adapter::Mpg123 do
+  let(:t){ TestClass.new }
+  let(:song) do
+    s = Song.new
+    s.stub(:path){'/duck/path'}
+    s
+  end
+
+  it 'can check if player is running' do
+    t.should respond_to :player_running?
+  end
+
+  it 'start the player if is not running' do
+    t.should_receive :start_player
+    t.should_not be_player_running
+    t.play_in_player song
+  end
+
+  context 'with active playback' do
+    before :each do
+      t.play_in_player song
+    end
+
+    it 'pause a song' do
+      t.should_receive(:send_to_player).with('pause')
+      t.pause_in_player
+    end
+
+    it 'stops a song' do
+      t.should_receive(:send_to_player).with('stop')
+      t.stop_in_player
+    end
+
+    it 'resume a paused song' do
+      t.pause_in_player
+      t.should_receive(:send_to_player).with("pause")
+      t.resume_in_player
+    end
+
+    it 'resume a stopped song' do
+      t.stop_in_player
+      t.should_receive(:start_player)
+      t.play_in_player song
+    end
+  end
+
+  context 'running actual mpg123 player', mplayer: true do
+    it 'dont show the initial text from mpg123' do
+      th = Thread.new do
+        class MplayerTest
+          include CultomePlayer
+        end
+
+        song1 = double(:song1, path: "/home/csoria/music/unknown/Torches/02 Pumped Up Kicks.mp3")
+        song2 = double(:song2, path: "/home/csoria/music/unknown/Torches/07 Houdini.mp3")
+        p = MplayerTest.new
+        p.prepare_environment(:rspec)
+
+        puts "Primera cancion..."
+        p.play_in_player(song1)
+        i = 0
+        while i < 3
+          sleep 1
+          i += 1
+        end
+
+        puts "Segunda cancion(running: #{p.player_running?})..."
+        p.play_in_player(song2)
+        i = 0
+        while i < 3
+          sleep 1
+          i += 1
+        end
+        puts "Terminado!"
+      end # Thread
+
+      th.join
+    end
+  end
+end