ituner 0.0.2

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,8 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in ituner.gemspec
+gemspec
+
+gem "rake"
+gem "rspec"
+gem "rr"

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require "rspec/core/rake_task"
+
+task "default" => "spec"
+
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = 'spec/**/*_spec.rb'
+  t.rspec_opts = ["--colour", "--format", "nested"]
+end

data/ituner.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "ituner/version"
+
+Gem::Specification.new do |gem|
+  
+  gem.name        = "ituner"
+  gem.summary     = "control iTunes using Ruby"
+  gem.homepage    = "http://github.com/mdub/ituner"
+  
+  gem.version     = ITuner::VERSION
+  gem.platform    = Gem::Platform::RUBY
+  
+  gem.authors     = ["Mike Williams"]
+  gem.email       = ["mdub@dogbiscuit.org"]
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.require_paths = ["lib"]
+
+  gem.add_runtime_dependency "rb-appscript"
+  
+end

data/lib/ituner.rb

@@ -0,0 +1 @@
+require 'ituner/itunes'

data/lib/ituner/collection.rb

@@ -0,0 +1,84 @@
+module ITuner
+  
+  class Collection
+    
+    def initialize(app_collection, item_type, item_class, &block)
+      @app_collection = app_collection
+      @item_type = item_type
+      @item_class = item_class
+      if block
+        self.extend(Module.new(&block))
+      end
+    end
+    
+    attr_reader :app_collection
+    attr_reader :item_class
+    attr_reader :item_type
+    
+    def get(index)
+      app_reference = app_collection[translate_index(index)]
+      wrap_item(resolve_reference(app_reference))
+    end
+    
+    alias :[] :get
+
+    def translate_index(index)
+      case index
+      when Integer
+        index + 1
+      else
+        index
+      end
+    end
+    
+    def size
+      app_collection.get.size
+    end
+    
+    def empty?
+      size == 0
+    end
+
+    def each
+      app_collection.get.each do |item|
+        yield wrap_item(item)
+      end
+    end
+    
+    include Enumerable
+    
+    def first
+      wrap_item(app_collection.first.get)
+    end
+
+    def last
+      wrap_item(app_collection.last.get)
+    end
+
+    def create(properties = {})
+      wrap_item(ITuner.itunes_app.make(:new => item_type, :with_properties => properties))
+    end
+    
+    def inspect
+      s = take(10).inspect
+      if size > 10
+        s[-1,1] = ", (and #{size - 10} more)]" 
+      end
+      s
+    end
+    
+    private 
+    
+    def resolve_reference(ref)
+      ref.get
+    rescue Appscript::CommandError
+      return nil
+    end
+  
+    def wrap_item(item)
+      item_class.new(item) if item
+    end
+    
+  end
+  
+end

data/lib/ituner/itunes.rb

@@ -0,0 +1,68 @@
+require 'appscript'
+require 'ituner/collection'
+require 'ituner/source'
+require 'ituner/playlist'
+require 'ituner/track'
+
+module ITuner
+  
+  class << self
+    
+    def itunes_app
+      @itunes_app ||= Appscript.app("iTunes")
+    end
+
+    def itunes
+      itunes_app.launch
+      ITunes.new(itunes_app)
+    end
+    
+  end
+  
+  class ITunes < Model
+    
+    def running?
+      app.is_running?
+    end
+    
+    action :play
+    action :pause
+    action :stop
+
+    def state
+      app.player_state.get
+    end
+
+    def playing?; state == :playing; end
+    def paused?;  state == :paused;  end
+    def stopped?; state == :stopped; end
+
+    def current_track
+      Track.new(app.current_track.get)
+    rescue Appscript::CommandError
+      nil
+    end
+
+    collection :sources
+
+    def library
+      sources["Library"]
+    end
+    
+    def playlists
+      library.playlists
+    end
+
+    def music
+      playlists["Music"]
+    end
+    
+    private
+    
+    def app
+      app_object
+    end
+    
+  end
+  
+end

data/lib/ituner/model.rb

@@ -0,0 +1,54 @@
+module ITuner
+  
+  class Model
+    
+    def initialize(app_object)
+      @app_object = app_object
+    end
+
+    attr_accessor :app_object
+
+    def ==(other)
+      other && (app_object == other.app_object)
+    end
+        
+    def inspect
+      s = "{" + self.class.name
+      if respond_to?(:name)
+        s += " #{name.inspect}"
+      end
+      s += "}"
+      s
+    end
+
+    class << self
+    
+      def property(name, app_name = name)
+        define_method(name) do
+          app_object.send(app_name).get
+        end
+      end
+
+      def collection(name, app_name = name, &block)
+        item_type = name.to_s.sub(/s$/,'').to_sym
+        item_class = ITuner.const_get(item_type.to_s.capitalize)
+        define_method(name) do
+          Collection.new(app_object.send(app_name), item_type, item_class, &block)
+        end
+      end
+      
+      def action(name, app_name = name)
+        define_method(name) do |*args|
+          app_object.send(app_name, *args)
+        end
+      end
+      
+    end
+
+    action :delete
+    
+    property :kind
+    
+  end
+  
+end

data/lib/ituner/playlist.rb

@@ -0,0 +1,38 @@
+require 'ituner/model'
+require 'ituner/track'
+
+module ITuner
+  
+  class Playlist < Model
+    
+    property :name
+    
+    collection :tracks do
+
+      def clear
+        app_collection.delete
+      end
+
+    end
+
+    def clear
+      tracks.clear
+    end
+    
+    def search(name, only = :all)
+      ITuner.itunes_app.search(app_object, :for => name, :only => only).map do |app_track|
+        Track.new(app_track)
+      end
+    end
+        
+    def add(track)
+      ITuner.itunes_app.duplicate(track.app_object, :to => app_object)
+    end
+
+    def play
+      app_object.play(:once => true)
+    end
+
+  end
+  
+end

data/lib/ituner/source.rb

@@ -0,0 +1,26 @@
+require 'ituner/model'
+require 'ituner/playlist'
+
+module ITuner
+  
+  class Source < Model
+    
+    property :name
+    
+    collection :playlists do
+      
+      def find_or_create(name)
+        get(name) || create(:name => name)
+      end
+      
+    end
+    
+    collection :tracks
+
+    def music
+      playlists["Music"]
+    end
+        
+  end
+  
+end

data/lib/ituner/track.rb

@@ -0,0 +1,32 @@
+require 'ituner/model'
+
+module ITuner
+
+  class Track < Model
+
+    property :name
+    property :artist
+    property :album
+
+    property :uid, :database_ID
+    
+    def play
+      app_object.play(:once => true)
+    end
+
+    class << self
+
+      include Appscript
+      
+      def find_by_uid(uid)
+        app_track = ITuner.itunes_app.tracks[its.database_ID.eq(uid)].first.get
+        Track.new(app_track)
+      rescue CommandError
+        nil
+      end
+      
+    end
+    
+  end
+
+end

data/lib/ituner/version.rb

@@ -0,0 +1,3 @@
+module ITuner
+  VERSION = "0.0.2"
+end

data/spec/ituner/collection_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe ITuner::Collection do
+  
+  before do
+    @collection = ITuner.itunes.playlists
+  end
+
+  describe "#size" do
+    it "returns the number of items" do
+      size = @collection.size
+      size.should be_kind_of(Integer)
+      size.should be > 5
+    end
+  end
+
+  describe "#get" do
+    
+    describe "with a string" do
+
+      it "returns the entry with matching name" do
+        @collection["Library"].should be_kind_of(ITuner::Playlist)
+        @collection["Library"].name.should == "Library"
+      end
+
+    end
+
+    describe "with a number" do
+
+      it "returns the entry in the referenced position" do
+        @collection[0].name.should == "Library"
+      end
+
+    end
+
+    describe "with a bogus name" do
+
+      it "returns nil" do
+        @collection["bogus"].should be_nil
+      end
+
+    end
+
+    describe "with an out-of-bounds number" do
+
+      it "returns nil" do
+        @collection[666].should be_nil
+      end
+
+    end
+    
+  end
+  
+  it "can be enumerated" do
+    @collection.should respond_to(:each)
+
+    @count = 0
+    @collection.each do |item|
+      @count += 1
+    end
+    @count.should == @collection.size
+  end
+
+  it "is Enumerable" do
+    @collection.should be_kind_of(Enumerable)
+  end
+  
+  describe "#create" do
+
+    before do
+      @collection["XYZ"].delete rescue nil
+    end
+    
+    it "creates a new item" do
+      xyz = @collection.create(:name => "XYZ")
+      xyz.should be_kind_of(ITuner::Playlist)
+      xyz.name.should == "XYZ"
+    end
+    
+    after do
+      @collection["XYZ"].delete rescue nil
+    end
+    
+  end
+  
+  describe "#inspect" do
+    
+    it "makes the collection looks like an array" do
+      @collection.inspect.should =~ /^\[.*\]$/
+    end
+
+    it "invokes #inspect on each element" do
+      stub(@collection).each { |block| [1,2,3].each(&block) }
+      stub(@collection).size { 3 }
+      @collection.inspect.should == "[1, 2, 3]"
+    end
+
+    context "when the collection contains more than 10 elements" do
+
+      it "invokes #inspect on each element" do
+        stub(@collection).each { |block| (1..20).each(&block) }
+        stub(@collection).size { 20 }
+        @collection.inspect.should == "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, (and 10 more)]"
+      end
+
+    end
+  
+  end
+
+end

data/spec/ituner/itunes_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe ITuner, "controls" do
+
+  before do 
+    @itunes = ITuner.itunes
+  end
+  
+  it "is running" do
+    @itunes.should be_running
+  end
+  
+  it "can play" do
+    @itunes.play
+    @itunes.should be_playing
+  end
+
+  it "can pause" do
+    @itunes.play
+    @itunes.pause
+    @itunes.should_not be_playing
+  end
+
+  describe "#current_track" do
+    
+    it "returns the current Track" do
+      @itunes.play
+      @itunes.current_track.should be_kind_of(ITuner::Track)
+    end
+    
+    after do
+      @itunes.stop
+    end
+    
+  end
+  
+  describe "#sources" do
+
+    it "returns the media sources" do
+      @sources = @itunes.sources
+      @sources.each do |source|
+        source.should be_kind_of(ITuner::Source)
+      end
+      @sources[0].name.should == "Library"
+      @sources[1].name.should == "Radio"
+    end
+
+  end
+
+  describe "#library" do
+    
+    it "returns the Library source" do
+      @library = @itunes.library
+      @library.should be_kind_of(ITuner::Source)
+      @library.name.should == "Library"
+    end
+    
+  end
+  
+end

data/spec/ituner/playlist_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe ITuner::Playlist do
+
+  before do
+    @playlist = ITuner.itunes.playlists["Library"]
+  end
+  
+  it "has a name" do
+    @playlist.name.should == "Library"
+  end
+
+  it "has tracks" do
+    @playlist.tracks.should be_kind_of(ITuner::Collection)
+  end
+  
+  describe "#search" do
+    
+    it "returns matching tracks" do
+      @playlist.search("FreeLoader").map(&:name).should include("Freddie Freeloader")
+      @playlist.search("Nirvana").map(&:name).should include("Smells Like Teen Spirit")
+    end
+
+    it "can be restricted" do
+      @playlist.search("Nirvana", :artists).map(&:name).should include("Smells Like Teen Spirit")
+      @playlist.search("Nirvana", :songs).map(&:name).should_not include("Smells Like Teen Spirit")
+    end
+    
+  end
+  
+  describe "#add" do
+    
+    before do 
+      @playlist = ITuner.itunes.playlists.create(:name => "Test")
+      @track = ITuner.itunes.music.tracks.first
+    end
+
+    after do 
+      @playlist.delete
+    end
+    
+    it "add a track to the playlist" do
+      @playlist.add(@track)
+      @playlist.tracks.size.should == 1
+    end
+  
+  end
+
+  describe "#clear" do
+
+    before do 
+      @playlist = ITuner.itunes.playlists.create(:name => "Test")
+    end
+    
+    after do 
+      @playlist.delete
+    end
+
+    it "removes all tracks" do 
+      ITuner.itunes.music.tracks.take(3).each do |track|
+        @playlist.add(track)
+      end
+      @playlist.tracks.size.should == 3
+      @playlist.clear
+      @playlist.tracks.size.should == 0
+    end
+    
+  end
+  
+end

data/spec/ituner/source_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe ITuner::Source do
+
+  before do
+    @source = ITuner.itunes.sources["Library"]
+  end
+  
+  it "has a name" do
+    @source.name.should == "Library"
+  end
+
+  describe "#playlists" do
+
+    it "returns playlists" do
+      @playlists = @source.playlists
+      @playlists.should_not be_empty
+      @playlists.each do |playlist|
+        playlist.should be_kind_of(ITuner::Playlist)
+      end
+    end
+
+    describe ".find_or_create" do
+
+      context "with the name of an existing playlist" do
+        it "finds the existing one" do
+          music = @source.music
+          @source.playlists.find_or_create("Music").should == music
+        end
+      end
+
+      context "with the name of a non-existant playlist" do
+
+        it "creates a new one" do
+          old_xxx = @source.playlists["XXX"]
+          old_xxx.delete unless old_xxx.nil?
+          new_xxx = @source.playlists.find_or_create("XXX")
+          new_xxx.should be_kind_of(ITuner::Playlist)
+          new_xxx.name.should == "XXX"
+        end
+
+      end
+
+    end
+    
+  end
+
+end

data/spec/ituner/track_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe ITuner::Track do
+  
+  before do
+    @itunes = ITuner.itunes 
+    @track = @itunes.library.tracks["Freddie Freeloader"]
+  end
+
+  it "has a name" do
+    @track.name.should == "Freddie Freeloader"
+  end
+
+  it "has an artist" do
+    @track.artist.should == "Miles Davis"
+  end
+
+  it "has an album" do
+    @track.album.should == "Kind Of Blue"
+  end
+
+  it "has a uid" do
+    @track.uid.should be_kind_of(Fixnum)
+  end
+  
+  it "can be played" do
+    @track.play
+  end
+  
+  describe "#play" do
+
+    before do
+      @itunes.stop
+    end
+
+    it "plays the song (and then stops)" do
+      stub.proxy(@track.app_object).play
+      @track.play
+      @itunes.should be_playing
+      @track.app_object.should have_received.play(:once => true)
+    end
+    
+  end
+  
+  describe ".find_by_uid" do
+    
+    context "with the uid of an existing track" do
+      it "returns the track" do
+        @reloaded_track = ITuner::Track.find_by_uid(@track.uid)
+        @reloaded_track.name.should == @track.name
+        @reloaded_track.uid.should == @track.uid
+      end
+    end
+
+    context "with a bogus uid" do
+      it "returns nil" do
+        ITuner::Track.find_by_uid(99999999999).should == nil
+      end
+    end
+    
+  end
+  
+  after do
+    @itunes.stop
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+require 'rspec'
+require 'ituner'
+require 'rr'
+require 'rr/adapters/rspec'
+
+module HaveReceivedSupport
+
+  def have_received(method = nil)
+    RR::Adapters::Rspec::InvocationMatcher.new(method)
+  end
+  
+end
+
+RSpec.configure do |config|
+
+  config.mock_with :rr
+  config.include HaveReceivedSupport
+  
+  config.after do
+    ITuner.itunes.stop
+  end
+  
+end
+

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: ituner
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Mike Williams
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-21 00:00:00 +11:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rb-appscript
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: 
+email: 
+- mdub@dogbiscuit.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Rakefile
+- ituner.gemspec
+- lib/ituner.rb
+- lib/ituner/collection.rb
+- lib/ituner/itunes.rb
+- lib/ituner/model.rb
+- lib/ituner/playlist.rb
+- lib/ituner/source.rb
+- lib/ituner/track.rb
+- lib/ituner/version.rb
+- spec/ituner/collection_spec.rb
+- spec/ituner/itunes_spec.rb
+- spec/ituner/playlist_spec.rb
+- spec/ituner/source_spec.rb
+- spec/ituner/track_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/mdub/ituner
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: control iTunes using Ruby
+test_files: 
+- spec/ituner/collection_spec.rb
+- spec/ituner/itunes_spec.rb
+- spec/ituner/playlist_spec.rb
+- spec/ituner/source_spec.rb
+- spec/ituner/track_spec.rb
+- spec/spec_helper.rb