squeezer-ruby 0.1.1 → 0.2.0

data/lib/squeezer/models/player.rb

@@ -120,58 +120,90 @@ module Squeezer
         power(:off)
       end
     
-      def <=>(target)
-        self.name <=> target.name
+      # fade in seconds
+      def play(fade=0)
+        cmd("#{id} play #{fade}")
+      end
+    
+      def stop
+        cmd("#{id} stop")
       end
       
-      # TODO method_missing anyone? Those find methods could be nice with a ghost method.
+      def pause
+        cmd("#{id} pause")
+      end
       
-      # beware of offline players, they still show up on the list
-      # test if those players are connected with Player#connected?
-      def players
-        player_map = Hash.new
-        count = cmd("player count ?").to_i
-        count.to_i.times do |index|
-          id = cmd("player id #{index} ?")
-          player_map[id] = Models::Player.new(id)
-        end
-        player_map
+      def playing?
+        mode == :play
       end
       
-      def self.all
-        self.new(nil).players
+      def stopped?
+        mode == :stop
       end
       
-      # handle duplicates in these find methods, specs expect only one result
-      def find_by_name(name)
-        find(:name => name)
+      def paused?
+        mode == :pause
       end
       
-      def self.find_by_name(name)
-        self.new(nil).find_by_name(name)
+      def mode
+        cmd("#{id} mode ?").to_sym
+      end
+    
+      def show(options)
+        cmd("#{id} show font:#{options[:font]} line2:#{options[:line2]} centered:#{options[:centered]} duration:#{options[:duration]}")
       end
       
-      def find_by_ip(ip)
-        find(:ip => ip)
+      def alert(message, options={})
+        options = {:line2 => URI.escape(message), :centered => true, :duration => 3, :font => :huge}.merge(options)
+        show(options)
       end
       
-      def self.find_by_ip(ip)
-        p = self.new(nil)
-        result = p.find_by_ip(ip)
-        p = nil
+      def blink(message, times, duration=1, options={})
+        times.times do
+          alert(message, :duration => duration)
+          sleep duration
+        end
+      end
+    
+      def playlist
+        Models::Playlist.new(id)
+      end
+    
+      def <=>(target)
+        self.name <=> target.name
+      end
+            
+      # beware of offline players, they still show up on the list
+      # test if those players are connected with Player#connected?
+      def players
+        Player.all
+      end
+      
+      def self.all
+        result = Array.new
+        count = Connection.exec("player count ?").to_i
+        count.to_i.times do |index|
+          id = Connection.exec("player id #{index} ?")
+          result << Models::Player.new(id)
+        end
         result
       end
       
-      def find_by_id(id)
-        find(:id => id)
+      # handle duplicates in these find methods, specs expect only one result
+      def self.find_by_name(name)
+        find(:name => name)
       end
       
+      def self.find_by_ip(ip)
+        find(:ip => ip)
+      end
+          
       def self.find_by_id(id)
-        self.new(nil).find_by_id(id)
+        find(:id => id)
       end
-      
-      def find(values)
-        players.each do |id,player|
+            
+      def self.find(values)
+        all.each do |player|
           match = true
           values.each do |property,value|
             match = false unless player.send(property.to_sym) == value
@@ -180,11 +212,7 @@ module Squeezer
         end
         return nil
       end
-      
-      def self.find(values)
-        self.new(nil).find(values)
-      end
-      
+            
     end
   end
 end

data/lib/squeezer/models/playlist.rb

@@ -0,0 +1,43 @@
+module Squeezer
+  module Models
+    
+    # initial playlist support
+    class Playlist < Model
+      
+      attr_reader :id
+      
+      def initialize(id, options={})
+        super options
+        @id = id
+      end
+      
+      def add(entity)
+        playlistcontrol(:cmd => :add, :entity => entity_name(entity), :id => entity.id)
+        true
+      end
+      
+      # starts playing directly
+      def load(entity)
+        playlistcontrol(:cmd => :load, :entity => entity_name(entity), :id => entity.id)
+        true
+      end
+      
+      def clear
+        cmd "#{id} playlist clear"
+      end
+      
+      private
+      
+      def entity_name(entity)
+        entity.class.to_s.downcase.split('::').last
+      end
+      
+      def playlistcontrol(options)
+        # TODO make better use of these options
+        # .. and what about entity lists?
+        cmd "#{id} playlistcontrol cmd:#{options[:cmd]} #{options[:entity]}_id:#{options[:id]}"
+      end
+      
+    end
+  end
+end

data/lib/squeezer/models/track.rb

@@ -0,0 +1,28 @@
+module Squeezer
+  module Models
+    
+    class Track < Model
+      attr_accessor :id, :name
+      
+      def initialize(record=nil)
+        unless record.nil?
+          @id = record[:id] if record.key?(:id)
+          @name = record[:title] if record.key?(:title)
+        end
+      end
+            
+      def self.total
+        Connection.exec("info total songs ?").to_i
+      end
+      
+      def self.all
+        results = Array.new
+        Model.extract_records(Connection.exec("tracks 0 #{total} charset:utf8 tags:s")).each do |record|
+          results << Track.new(record)
+        end
+        results
+      end
+    end
+    
+  end
+end

data/lib/squeezer/version.rb

@@ -1,4 +1,4 @@
 module Squeezer
   # The version of the gem
-  VERSION = '0.1.1'.freeze unless defined?(::Squeezer::VERSION)
+  VERSION = '0.2.0'.freeze unless defined?(::Squeezer::VERSION)
 end

data/script/console

@@ -0,0 +1,16 @@
+#! /usr/bin/env ruby
+
+libs = []
+libs << "irb/completion"
+libs << File.expand_path("../../lib/squeezer.rb", __FILE__)
+
+command_line = []
+command_line << "irb"
+command_line << libs.inject("") { |acc, lib| acc + %( -r "#{lib}") }
+command_line << "--simple-prompt"
+command_line << "-d"
+command_line << "-W1"
+command = command_line.join(" ")
+
+puts "Welcome to the Squeezer console interface."
+exec command

data/spec/spec_helper.rb

@@ -1,41 +1,48 @@
-require 'simplecov'
-SimpleCov.start do
-  add_group 'Squeezer', 'lib/squeezer'
-  add_group 'Specs', 'spec'
-end
+require 'rubygems'
+require 'spork'
 
-#require 'mocha'
-RSpec.configure do |config|
-  config.mock_with :mocha
+Spork.prefork do
+  # Loading more in this block will cause your tests to run faster. However, 
+  # if you change any configuration or code from libraries loaded here, you'll
+  # need to restart spork for it take effect.
   
-  config.before(:each) do
-    # TODO add authentication stuff to the mock
-    @connection = mock("connection")
-    sock = mock("sock")
-    sock.stubs(:close).returns(true)
-    @connection.stubs(:sock).returns(sock)
-    @connection.stubs(:cmd).with("exit")
-
-    # Net::Telnet.stubs(:new).returns(@connection)
-    
-    # maybe find a better way to mock the connection? Because the mock
-    # stays in memory of the API's eigenclass if we mocked the telnet
-    # connection directly. So we mock the connection getter instead.
-    # But since we didn't find a way to mock a module method, we mock the
-    # getter per class.
-    Squeezer::Models::Player.any_instance.stubs(:connection).returns(@connection)
-    Squeezer::Client.any_instance.stubs(:connection).returns(@connection)
+  require 'rspec'
+  require 'simplecov'
+  SimpleCov.start do
+    add_group 'Squeezer', 'lib/squeezer'
+    add_group 'Specs', 'spec'
+    add_filter __FILE__
   end
   
-  config.after(:each) do
-    # Squeezer.exit
+  RSpec.configure do |config|
+    config.mock_with :mocha
+
+    config.before(:each) do
+      # TODO add authentication stuff to the mock
+      @connection = mock("connection")
+      sock = mock("sock")
+      sock.stubs(:close).returns(true)
+      @connection.stubs(:sock).returns(sock)
+      @connection.stubs(:cmd).with("exit")
+
+      Net::Telnet.stubs(:new).returns(@connection)
+    end
+
+    config.after(:each) do
+      Squeezer.exit
+    end
   end
 end
 
-require File.expand_path('../../lib/squeezer', __FILE__)
+Spork.each_run do
+  # This code will be run each time you run your specs.
+
+  load File.expand_path('../../lib/squeezer.rb', __FILE__)
+end
 
-require 'rspec'
 
 def stub_connection
   @connection.stubs(:cmd)
-end
+end
+
+

data/spec/squeezer/client/database_spec.rb

@@ -6,31 +6,31 @@ describe Squeezer::Client do
   end
   
   describe ".total_*" do
-    it "should return the entity's total artists" do
+    it "should return the total artists" do
       stub_connection.with("info total artists ?").returns("info total artists 2\n")
       @client.total_artists.should == 2
     end
     
-    it "should return the entity's total albums" do
+    it "should return the total albums" do
       stub_connection.with("info total albums ?").returns("info total albums 4\n")
       @client.total_albums.should == 4
     end
     
-    it "should return the entity's total genres" do
+    it "should return the total genres" do
       stub_connection.with("info total genres ?").returns("info total genres 6\n")
       @client.total_genres.should == 6
     end
     
-    it "should return the entity's total songs" do
+    it "should return the total songs" do
       stub_connection.with("info total songs ?").returns("info total songs 8\n")
-      @client.total_songs.should == 8
+      @client.total_tracks.should == 8
     end
   end
   
   describe ".artists" do
     before do
       stub_connection.with("info total artists ?").returns("info total artists 1\n")
-      stub_connection.with("artists 0 2 charset:utf8 tags:s").returns("artists 0 2 charset%3Autf8 tags%3As id%3A4631 artist%3AVarious%20Artists textkey%3A%20 id%3A3998 artist%3A1200%20Micrograms textkey%3A1 count%3A434\n")
+      stub_connection.with("artists 0 2 charset:utf8 tags:s").returns("artists 0 2 charset%3Autf8 tags%3As id%3A4631 artist%3AVarious%20Artists textkey%3A%20 id%3A3998 artist%3AAwesome%20Artist textkey%3AA count%3A434\n")
     end
     
     it "should return a list with Artist models" do
@@ -44,5 +44,96 @@ describe Squeezer::Client do
       artists.first.name.should == "Various Artists"
     end
   end
+  
+  describe ".albums" do
+    before do
+      stub_connection.with("info total albums ?").returns("info total albums 2\n")
+      stub_connection.with("albums 0 2 charset:utf8 tags:tqs").returns("albums 0 2 charset%3Autf8 tags%3Atqs id%3A4631 title%3AAwesome%20Album disccount%3A1 textkey%3AA id%3A3998 title%3AAnother%20Album textkey%3AA count%3A434\n")
+    end
+    
+    it "should return a list with Album models" do
+      albums = @client.albums
+      albums.first.should be_a Squeezer::Models::Album
+    end
+    
+    it "should return a list with all the albums" do
+      albums = @client.albums
+      albums.should have(2).things
+      albums.first.name.should == "Awesome Album"
+      albums.first.discs.should == 1
+    end
+  end
+  
+  describe ".tracks" do
+    before do
+      stub_connection.with("info total songs ?").returns("info total songs 2\n")
+      stub_connection.with("tracks 0 2 charset:utf8 tags:s").returns("albums 0 2 charset%3Autf8 tags%3As id%3A4631 title%3AAwesome%20Track textkey%3AA id%3A3998 title%3AAnother%20Track textkey%3AA count%3A434\n")
+    end
+    
+    it "should return a list with Track models" do
+      tracks = @client.tracks
+      tracks.first.should be_a Squeezer::Models::Track
+    end
+    
+    it "should return a list with all the tracks" do
+      tracks = @client.tracks
+      tracks.should have(2).things
+      tracks.first.name.should == "Awesome Track"
+    end
+  end
+  
+  describe ".genres" do
+    before do
+      stub_connection.with("info total genres ?").returns("info total genres 2\n")
+      stub_connection.with("genres 0 2 charset:utf8 tags:s").returns("genres 0 2 charset%3Autf8 tags%3As id%3A4631 genre%3AAwesome%20Genre textkey%3AA id%3A3998 genre%3AAnother%20Genre textkey%3AA count%3A434\n")
+    end
+    
+    it "should return a list with Genre models" do
+      genres = @client.genres
+      genres.first.should be_a Squeezer::Models::Genre
+    end
+    
+    it "should return a list with all the genres" do
+      genres = @client.genres
+      genres.should have(2).things
+      genres.first.name.should == "Awesome Genre"
+    end
+  end
+  
+  context "database scanning" do
+    describe ".rescan!" do  
+      it "should initiate a rescan of the music database" do
+        stub_connection.with("rescan").returns("rescan")
+        @client.rescan!.should be true
+      end
+    end
     
+    describe ".scanning?" do  
+      it "should indicate whether or not the database is scanning" do
+        stub_connection.with("rescan ?").returns("rescan 1")
+        @client.scanning?.should be true
+      end
+    end
+    
+    describe ".abortscan!" do  
+      it "should abort a scan" do
+        stub_connection.with("abortscan").returns("abortscan")
+        @client.abortscan!.should be true
+      end
+    end
+    
+    describe ".wipecache!" do  
+      it "should wipe the database" do
+        stub_connection.with("wipecache").returns("wipecache")
+        @client.wipecache!.should be true
+      end
+    end
+    
+    describe ".rescan_progress" do  
+      it "should return the rescan progress" do
+        stub_connection.with("rescanprogress").returns("rescan%3A1 directory%3A100 musicip%3A100 mergeva%3A100 cleanup1%3A100 cleanup2%3A100 steps%3Adirectory%2Cmusicip%2Cmergeva%2Ccleanup1%2Ccleanup2 totaltime%3A00%3A00%3A38")
+        @client.rescan_progress[:rescan].to_boolean.should be true
+      end
+    end
+  end
 end