cultome_player 2.0.0 → 2.0.2

data/.coveralls.yml

@@ -1 +0,0 @@
-service_name: travis-ci

data/.gitignore

@@ -1,24 +0,0 @@
-*.gem
-*.rbc
-.bundle
-.config
-.yardoc
-Gemfile.lock
-InstalledFiles
-_yardoc
-coverage
-doc/
-lib/bundler/man
-pkg
-rdoc
-spec/reports
-test/tmp
-test/version_tmp
-tmp
-*.swp
-tester.rb
-*.tmp
-TODO
-checklist
-spec/db.dat
-spec/db.log

data/.rspec

@@ -1,2 +0,0 @@
---color
---format progress

data/.travis.yml

@@ -1,7 +0,0 @@
-language: ruby
-rvm:
-    - 2.0
-script: rspec spec
-
-before_install:
-  - sudo apt-get install libtag1-dev

data/db/001_create_schema.rb

@@ -1,58 +0,0 @@
-
-class CreateSchema < ActiveRecord::Migration
-  def self.up
-    create_table :songs do |t|
-      t.string :name # If I Had A Gun
-      t.integer :artist_id, default: 0 # Noel Gallagher
-      t.integer :album_id, default: 0 # High Flying Birds
-      t.integer :year # 2011
-      t.integer :track # 3
-      t.integer :duration # 210 sec
-      t.integer :drive_id
-      t.string :relative_path
-      t.integer :points, default: 0
-      t.integer :plays, default: 0
-      t.datetime :last_played_at
-      t.timestamps
-    end
-
-    create_table :albums do |t|
-      t.string :name
-      t.integer :points
-      t.timestamps
-    end
-
-    create_table :artists do |t|
-      t.string :name
-      t.integer :points
-      t.timestamps
-    end
-
-    create_table :genres do |t|
-      t.integer :points
-      t.string :name
-    end
-
-    create_table :genres_songs, id: false do |t|
-      t.integer :song_id
-      t.integer :genre_id
-    end
-
-    create_table :drives do |t|
-      t.string :name
-      t.string :path
-      t.boolean :connected, default: true
-      t.timestamps
-    end
-  end
-
-  def self.down
-    drop_table :songs
-    drop_table :albums
-    drop_table :artists
-    drop_table :genres
-    drop_table :genres_songs
-    drop_table :drives
-  end
-end
-

data/spec/cultome_player/command/processor_spec.rb

@@ -1,168 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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