shortwave 0.0.1

data/lib/shortwave/model/playlist.rb

@@ -0,0 +1,36 @@
+module Shortwave
+  module Model
+    # A playlist
+    #
+    # === Attributes
+    #
+    # +id+:: id
+    # +title+:: title
+    # +description+:: description
+    # +created_at+:: Creation time
+    # +size+:: Number of tracks in the playlist
+    # +duration+:: length in milliseconds of the playlist
+    # +creator_url+:: Last.fm url of creator
+    # +url+:: Last.fm url of playlist
+    class Playlist < BaseModel
+      element :id, Integer
+      element :title, String
+      element :description, String
+      element :created_at, Time, :tag => "date"
+      element :size, Integer
+      element :duration, Integer
+      element :streamable, Boolean
+      element :creator_url, String, :tag => "creator"
+      element :url, String
+      
+      def streamable?
+        @streamable
+      end
+
+      # This can only be called on a user's own playlist
+      def add_track(track)
+        @session.playlist_facade.add_track(id, track.name, track.artist_name)
+      end
+    end
+  end
+end

data/lib/shortwave/model/shout.rb

@@ -0,0 +1,21 @@
+module Shortwave
+  module Model
+    # A shout message on Last.fm
+    #
+    # === Attributes
+    #
+    # +message+:: The message text
+    # +time+:: The time the message was written
+    class Shout < BaseModel
+      tag "shout"
+      element :message, String, :tag => "body"
+      element :time, Time, :tag => "date"
+      element :author, String
+
+      # The user who left the shout message
+      def user
+        @user ||= @session.user.build(:name => author)
+      end
+    end
+  end
+end

data/lib/shortwave/model/tag.rb

@@ -0,0 +1,47 @@
+module Shortwave
+  module Model
+    # A Last.fm tag
+    #
+    # ===Attributes
+    #
+    # +name+:: Tag text
+    # +count+:: Number of times this tag has been applied
+    # +url+:: URL on Last.fm site
+    class Tag < BaseModel
+      element :name, String
+      element :count, Integer
+      element :url, String
+      element :streamable, Boolean
+
+      # Can music be streamed from this tag?
+      def streamable?
+        streamable
+      end
+
+      # Returns similar tags to this one.
+      def similar
+        link :similar, :Tag, name
+      end
+      
+      # Returns the most popular albums tagged with this tag.
+      def albums
+        link :top_albums, :Album, name
+      end
+      
+      # Returns the most popular artists tagged with this tag.
+      def artists
+        link :top_artists, :Artist, name
+      end
+      
+      # Returns the most popular tracks tagged with this tag.
+      def tracks
+        link :top_tracks, :Track, name
+      end
+
+      # Returns the tag text
+      def to_s
+        name
+      end
+    end
+  end
+end

data/lib/shortwave/model/track.rb

@@ -0,0 +1,71 @@
+module Shortwave
+  module Model
+    # A track. Tracks are taggable and sharable.
+    #
+    # === Attributes
+    #
+    # +name+:: Track name
+    # +id+:: Last.fm id
+    # +mbid+:: Musicbrainz ID
+    # +listeners+:: number of listeners
+    # +play_count+:: number of times played
+    # +duration+:: Track duration in milliseconds
+    # +url+:: Track url on Last.fm
+    # +artist+:: Track's artist
+    # +album+:: Album track appears on.
+    class Track < BaseModel
+      element :name, String
+      element :id, Integer
+      element :listeners, Integer
+      element :play_count, Integer, :tag => "playcount"
+      element :mbid, String
+      element :duration, Integer
+      element :url, String
+      element :streamable, Boolean
+      has_one :artist, Artist
+      has_one :album, Album
+
+      identified_by "artist.name", :name
+      taggable 
+      sharable
+
+      # The most popular tags applied to this track
+      def tags
+        link :top_tags, :Tag, identifiers
+      end
+
+      # This track's fans
+      def fans
+        link :top_fans, :User, identifiers
+      end
+
+      # Similar tracks to this one.
+      def similar
+        link :similar, :Track, identifiers
+      end
+
+      # Love this track
+      def love
+        @session.track_facade.ban(name, artist.name)
+        # TODO include scrobble api call
+      end
+
+      # Don't play this track again.
+      def ban
+        @session.track_facade.love(name, artist.name)
+        # TODO include scrobble api call
+      end
+      
+      # Can this track be streamed
+      def streamable?
+        @streamable
+      end
+
+      private
+
+      def identifiers
+        mbid && ! mbid.empty?() ? {:mbid => mbid} : {:artist => artist.name, :track => name}
+      end
+    end
+  end
+end

data/lib/shortwave/model/user.rb

@@ -0,0 +1,70 @@
+module Shortwave
+  module Model
+    class User < BaseModel
+      element :name, String
+      element :id, Integer
+      element :real_name, String, :tag => "realname"
+      element :url, String
+      element :image, String
+      element :language, String, :tag => "lang"
+      element :country, String
+      element :age, Integer
+      element :gender, String
+      element :subscriber, Boolean
+      element :play_count, Integer, :tag => "playcount"
+
+      identified_by :name
+      shoutable
+      include WeeklyCharts
+
+      # Returns the events that this user is attending.
+      def events
+        link :events, :Event, name
+      end
+
+      # Returns the events a user has attended.
+      def past_events
+        link :past_events, :Event, name
+      end
+
+      # Returns the recent tracks played by this user.
+      def recent_tracks
+        link :recent_tracks, :Track, name
+      end
+
+      # Returns tracks a user has "loved".
+      def loved_tracks
+        link :loved_tracks, :Track, name
+      end
+
+      # Returns other Last.fm users with similar taste to this user.
+      def neighbours
+        link :neighbours, :User, name
+      end
+
+      # Returns the first 50 of a user's friends on Last.fm
+      def friends
+        link :friends, :User, name
+      end
+
+      # Returns a user's playlists
+      def playlists
+        link :playlists, :Playlist, name
+      end
+
+      # Returns events this user may be interested in.
+      def recommended_events
+        link :recommended_events, :Event
+      end
+
+      # Returns the first 50 artists this user may be interested in.
+      def recommended_artists
+        link :recommended_artists, :Artist
+      end
+
+      def compare_with(other_user)
+        Comparison.parse(@session.tasteometer_facacde.compare("user", "user", name, other_user.name), :single => true)
+      end
+    end
+  end
+end

data/lib/shortwave/model/venue.rb

@@ -0,0 +1,37 @@
+require 'forwardable'
+
+module Shortwave
+  module Model
+    # A venue that hosts events.
+    #
+    # === Attributes
+    #
+    # +id+:: Last.fm id
+    # +name+:: Venue name
+    # +url+:: Venue url on Last.fm
+    # +location+:: Venue's location
+    # +city+:: Venue city
+    # +street_address+:: Venue street address
+    # +country+:: Venue country
+    # +postcode+:: Venue post code
+    class Venue < BaseModel
+      extend Forwardable
+      def_delegators(:location, :city, :street_address, :country, :postcode)
+
+      element :id, Integer
+      element :name, String
+      element :url, String
+      has_one :location, "Shortwave::Model::Location"
+
+      # Returns events showing at this venue.
+      def events
+        link :events, :Event, id
+      end
+
+      # Returns past events from this venue.
+      def past_events
+        link :past_events, :Event, id
+      end
+    end
+  end
+end

data/lib/shortwave/model/weekly_charts.rb

@@ -0,0 +1,31 @@
+module Shortwave
+  module Model
+    module WeeklyCharts
+      # Returns the most popular albums from this group for the last week
+      def album_chart
+        link :weekly_album_chart, "Album", name
+      end
+
+      # Returns the most popular artists from this group for the last week
+      def artist_chart
+        link :weekly_artist_chart, "Artist", name
+      end
+
+      # Returns the most popular tracks from this group for the last week
+      def track_chart
+        link :weekly_track_chart, "Track", name
+      end
+
+      # Returns an array of Time ranges, repesenting the weeks charts are available
+      def chart_dates
+        @chart_dates ||= charts.map {|cd| cd.from..cd.to }.reverse
+      end
+
+      private
+
+      def charts
+        @charts ||= link :weekly_chart_list, "ChartDates", name
+      end
+    end
+  end
+end

data/lib/shortwave/providers.rb

@@ -0,0 +1,161 @@
+module Shortwave
+  module Provider
+    # Intended to be mixed in to authentication classes
+    module ProviderMethods
+      [:album, :artist, :group, :location, :playlist, :track, :tag, :user, :venue].each do |name|
+        klass_name = name.to_s.capitalize
+        module_eval <<-EOV
+          def #{name}
+            @#{name}_provider ||= Provider::#{klass_name}Provider.new(#{name}_facade)
+          end
+
+          def #{name}_facade
+            @#{name}_facade ||= Facade::#{klass_name}.new(self)            
+          end
+        EOV
+      end
+
+      def event_facade
+        @event_facade ||= Facade::Event.new(self)
+      end
+
+      def location_facade
+        @location_facade ||= Facade::Geo.new(self)            
+      end
+
+      def tasteometer_facacde
+        @tasteometer_facade ||= Facade::Tasteometer.new(self)
+      end
+    end
+
+
+    # You should generally use an instance of this class provided by a session:
+    # session.album
+    class BaseProvider
+      # Creates a provider with a facade
+      def initialize(facade)
+        @klass  = Model.const_get(self.class.name.split("::").last.sub("Provider",''))
+        @facade = facade
+      end
+
+      # Builds a model object.
+      def build(attributes)
+        model = @klass.new
+        attributes.each {|attr, value| model.send("#{attr}=".to_sym, value) }
+        model.session = @facade.session
+        model
+      end
+
+      protected
+
+      # Defines a search method on this provider
+      def self.searchable
+        define_method :search do |name|
+          parse_collection @facade.search(name)
+        end
+      end
+
+      def self.identifiable_by_mbid
+        define_method :get_by_id do |mbid|
+          mbid = mbid.uuid if mbid.respond_to? :uuid
+          parse_model @facade.info(:mbid => mbid)
+        end
+      end
+
+      # Parses an xml response into a Shortwave::Model::* object
+      def parse_model(response)
+        model = @klass.parse(response, :single => true)
+        model.session = @facade.session
+        model
+      end
+
+      # Parses an xml response into an array of  Shortwave::Model::* objects
+      def parse_collection(response)
+        @klass.parse(response).each {|model| model.session = @facade.session }
+      end
+    end
+
+    class PlaylistProvider < BaseProvider
+      def create(title, description=nil)
+        hsh = description ? {:description => description} : {}
+        parse_model @facade.create(hsh.merge(:title => title))
+      end
+    end
+
+    # Produces album objects.
+    class AlbumProvider < BaseProvider
+      searchable
+      identifiable_by_mbid
+
+      # Gets an album, given an artist name and an album name
+      def get(artist, name)
+        parse_model @facade.info(:artist => artist, :album => name)
+      end
+    end
+
+
+    # Produces artist objects.
+    class ArtistProvider < BaseProvider
+      searchable
+      identifiable_by_mbid
+
+      def get(artist)
+        parse_model @facade.info(:artist => artist)
+      end
+    end
+
+
+    class GroupProvider < BaseProvider
+    end
+
+
+    # Locations can only be built
+    class LocationProvider < BaseProvider
+    end
+
+
+    # Produces Tag objects
+    class TagProvider < BaseProvider
+      searchable
+
+      # Returns a tag named "name"
+      def get(name)
+        parse_model @facade.search(name)
+      end
+
+      # Returns the most popular tags from Last.fm
+      def popular
+        parse_collection @facade.top_tags
+      end
+    end
+
+
+    # Produces track objects.
+    class TrackProvider < BaseProvider
+      searchable
+      identifiable_by_mbid
+
+      # Gets a track, given an artist name and a track name
+      def get(artist, name)
+        parse_model @facade.info(:artist => artist, :track => name)
+      end
+    end
+
+
+    # Produces Venue objects
+    class VenueProvider < BaseProvider
+      def search(name, country=nil)
+        hsh = {}
+        hsh[:country] = country if country
+        parse_collection @facade.search(name, hsh)
+      end
+    end
+
+
+    class UserProvider < BaseProvider
+      def logged_in_user
+        parse_model @facade.info
+      end
+    end
+  end
+end