pandoru 0.1.0

data/lib/pandoru/models/_base.rb

@@ -0,0 +1,363 @@
+require 'time'
+
+module Pandoru
+  module Models
+    # Simple base model for Pandora API objects
+    class Base
+      attr_reader :data
+
+      def self.fields
+        @fields ||= {}
+      end
+
+      def self.field(name, json_key = nil, type: nil, &block)
+        json_key ||= name.to_s
+        fields[name] = { json_key: json_key, type: type, formatter: block }
+        attr_accessor name
+      end
+
+      def self.date_field(name, json_key = nil)
+        field(name, json_key, type: :date)
+      end
+
+      def self.from_json(api_client, data)
+        return nil unless data
+        instance = new(data, api_client)
+        instance.populate_from_json(data)
+        instance
+      end
+
+      def self.from_json_list(api_client, data_list)
+        return [] unless data_list
+        data_list.map { |data| from_json(api_client, data) }
+      end
+
+      def initialize(data = {}, api_client = nil)
+        @data = data
+        @api_client = api_client
+      end
+
+      def populate_from_json(data)
+        self.class.fields.each do |name, config|
+          json_key = config[:json_key]
+          type = config[:type]
+          formatter = config[:formatter]
+          
+          value = data[json_key]
+          
+          # Apply type conversion
+          value = case type
+                  when :date
+                    parse_date(value)
+                  when :boolean
+                    parse_boolean(value)
+                  else
+                    value
+                  end
+          
+          # Apply custom formatter if provided
+          value = formatter.call(value) if formatter && value
+          
+          instance_variable_set("@#{name}", value)
+        end
+      end
+
+      def to_h
+        hash = {}
+        self.class.fields.each do |name, _|
+          hash[name] = instance_variable_get("@#{name}")
+        end
+        hash
+      end
+
+      def inspect
+        attrs = self.class.fields.keys.map do |name|
+          value = instance_variable_get("@#{name}")
+          "#{name}=#{value.inspect}"
+        end.join(' ')
+        "#<#{self.class.name} #{attrs}>"
+      end
+
+      private
+
+      def parse_date(value)
+        return nil unless value
+        if value.is_a?(Hash) && value['time']
+          Time.at(value['time'] / 1000.0).utc
+        elsif value.is_a?(Numeric)
+          Time.at(value / 1000.0).utc
+        else
+          value
+        end
+      end
+
+      def parse_boolean(value)
+        case value
+        when true, false
+          value
+        when 'true', '1', 1
+          true
+        when 'false', '0', 0
+          false
+        else
+          value
+        end
+      end
+    end
+
+    # Base class for collections of models
+    class Collection < Base
+      include Enumerable
+
+      def initialize(data = {}, api_client = nil)
+        super
+        @items = []
+      end
+
+      def <<(item)
+        @items << item
+      end
+
+      def [](index)
+        @items[index]
+      end
+
+      def each(&block)
+        @items.each(&block)
+      end
+
+      def length
+        @items.length
+      end
+      alias_method :size, :length
+      alias_method :count, :length
+
+      def empty?
+        @items.empty?
+      end
+
+      def first
+        @items.first
+      end
+
+      def last
+        @items.last
+      end
+
+      def to_a
+        @items
+      end
+    end
+
+    # PandoraModel base class similar to Python implementation
+    class PandoraModel
+      def self.fields
+        @fields ||= {}
+      end
+
+      def self.field(name, json_key = nil, type: nil, &block)
+        json_key ||= name.to_s
+        fields[name] = { json_key: json_key, type: type, formatter: block }
+        attr_accessor name
+      end
+
+      def self.date_field(name, json_key = nil)
+        field(name, json_key, type: :date)
+      end
+
+      def self.from_json(api_client, data)
+        return nil unless data
+        instance = new(api_client)
+        instance.populate_from_json(data)
+        instance
+      end
+
+      def self.from_json_list(api_client, data_list)
+        return [] unless data_list
+        data_list.map { |data| from_json(api_client, data) }
+      end
+
+      def initialize(api_client)
+        @api_client = api_client
+      end
+
+      def populate_from_json(data)
+        self.class.fields.each do |name, config|
+          json_key = config[:json_key]
+          type = config[:type]
+          formatter = config[:formatter]
+          
+          value = data[json_key]
+          
+          # Apply type conversion
+          value = case type
+                  when :date
+                    parse_date(value)
+                  when :boolean
+                    parse_boolean(value)
+                  else
+                    value
+                  end
+          
+          # Apply custom formatter if provided
+          value = formatter.call(value) if formatter && value
+          
+          instance_variable_set("@#{name}", value)
+        end
+      end
+
+      def to_h
+        hash = {}
+        self.class.fields.each do |name, _|
+          hash[name] = instance_variable_get("@#{name}")
+        end
+        hash
+      end
+
+      def inspect
+        attrs = self.class.fields.keys.map do |name|
+          value = instance_variable_get("@#{name}")
+          "#{name}=#{value.inspect}"
+        end.join(' ')
+        "#<#{self.class.name} #{attrs}>"
+      end
+
+      private
+
+      def parse_date(value)
+        return nil unless value
+        if value.is_a?(Hash) && value['time']
+          Time.at(value['time'] / 1000.0).utc
+        elsif value.is_a?(Numeric)
+          Time.at(value / 1000.0).utc
+        else
+          value
+        end
+      end
+
+      def parse_boolean(value)
+        case value
+        when true, false
+          value
+        when 'true', '1', 1
+          true
+        when 'false', '0', 0
+          false
+        else
+          value
+        end
+      end
+    end
+
+    # List Model for indexed collections
+    class PandoraListModel < PandoraModel
+      include Enumerable
+
+      def self.from_json(api_client, data)
+        instance = new(api_client)
+        instance.populate_from_json(data)
+
+        # Extract the list items
+        list_key = instance.class.list_key
+        list_model = instance.class.list_model
+        
+        if list_key && list_model && data[list_key]
+          items = list_model.from_json_list(api_client, data[list_key])
+          instance.instance_variable_set(:@items, items)
+          
+          # Create index if specified
+          if instance.class.index_key
+            index = {}
+            items.each { |item| index[item.send(instance.class.index_key)] = item }
+            instance.instance_variable_set(:@index, index)
+          end
+        else
+          instance.instance_variable_set(:@items, [])
+          instance.instance_variable_set(:@index, {})
+        end
+
+        instance
+      end
+
+      def self.list_key
+        @list_key
+      end
+
+      def self.list_model
+        @list_model
+      end
+
+      def self.index_key
+        @index_key
+      end
+
+      def self.set_list_config(list_key:, list_model:, index_key: nil)
+        @list_key = list_key
+        @list_model = list_model
+        @index_key = index_key
+      end
+
+      def initialize(api_client)
+        super(api_client)
+        @items = []
+        @index = {}
+      end
+
+      def each(&block)
+        @items.each(&block)
+      end
+
+      def [](key)
+        if key.is_a?(Integer)
+          @items[key]
+        else
+          @index[key] if @index
+        end
+      end
+
+      def []=(index, value)
+        @items[index] = value if index.is_a?(Integer)
+      end
+
+      def size
+        @items.size
+      end
+
+      def length
+        @items.length
+      end
+
+      def empty?
+        @items.empty?
+      end
+    end
+
+    # Dictionary List Model
+    # For models that have both array and hash-like access patterns
+    class PandoraDictListModel < PandoraListModel
+      # Additional dictionary-like methods can be added here
+    end
+
+    # Date Field similar to Python implementation
+    class DateField
+      attr_reader :field
+
+      def initialize(field)
+        @field = field
+      end
+
+      def formatter(api_client, data, value)
+        return nil unless value
+        return nil if value.is_a?(Hash) && value.empty?
+        
+        if value.is_a?(Hash) && value["time"]
+          Time.at(value["time"] / 1000.0).utc
+        elsif value.is_a?(Numeric)
+          Time.at(value / 1000.0).utc
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/pandoru/models/bookmark.rb

@@ -0,0 +1,81 @@
+require_relative '_base'
+
+module Pandoru
+  module Models
+    class Bookmark < Base
+      field :bookmark_token, 'bookmarkToken'
+      field :music_token, 'musicToken'
+      field :artist_name, 'artistName'
+      field :song_name, 'songName'
+      field :art_url, 'artUrl'
+      field :sample_url, 'sampleUrl'
+      field :sample_gain, 'sampleGain'
+      field :album_name, 'albumName'
+      date_field :date_created, 'dateCreated'
+
+      def song_bookmark?
+        !song_name.nil?
+      end
+
+      def artist_bookmark?
+        song_name.nil?
+      end
+
+      def delete
+        return false unless @api_client
+        if song_bookmark?
+          @api_client.delete_song_bookmark(bookmark_token)
+        else
+          @api_client.delete_artist_bookmark(bookmark_token)
+        end
+        true
+      end
+    end
+
+    class BookmarkList < Collection
+      def self.from_json(api_client, data)
+        instance = new(data, api_client)
+        
+        # Add song bookmarks
+        if data['songs']
+          Bookmark.from_json_list(api_client, data['songs']).each do |bookmark|
+            instance << bookmark
+          end
+        end
+
+        # Add artist bookmarks (ensure song_name is nil for artists)
+        if data['artists']
+          data['artists'].each do |artist_data|
+            artist_data['songName'] = nil unless artist_data.key?('songName')
+            bookmark = Bookmark.from_json(api_client, artist_data)
+            instance << bookmark
+          end
+        end
+
+        instance
+      end
+
+      def song_bookmarks
+        select(&:song_bookmark?)
+      end
+
+      def artist_bookmarks
+        select(&:artist_bookmark?)
+      end
+
+      def find_song_bookmark(song_name, artist_name = nil)
+        song_bookmarks.find do |bookmark|
+          matches_song = bookmark.song_name&.casecmp(song_name) == 0
+          matches_artist = artist_name.nil? || bookmark.artist_name&.casecmp(artist_name) == 0
+          matches_song && matches_artist
+        end
+      end
+
+      def find_artist_bookmark(artist_name)
+        artist_bookmarks.find do |bookmark|
+          bookmark.artist_name&.casecmp(artist_name) == 0
+        end
+      end
+    end
+  end
+end

data/lib/pandoru/models/playlist.rb

@@ -0,0 +1,91 @@
+require_relative '_base'
+
+module Pandoru
+  module Models
+    class PlaylistItem < Base
+      field :track_token, "trackToken"
+      field :artist_name, "artistName"
+      field :album_name, "albumName"
+      field :song_name, "songName"
+      field :song_rating, "songRating"
+      field :track_length, "trackLength"
+      field :allow_feedback, "allowFeedback", type: :boolean
+      field :ad_token, "adToken"
+      field :audio_url_map, "audioUrlMap"
+      field :is_ad, "isAd", type: :boolean
+
+      def initialize(data = {}, api_client = nil)
+        super(data, api_client)
+      end
+
+      def is_ad?
+        @is_ad || false
+      end
+
+      def audio_url(quality = nil)
+        return nil unless @audio_url_map
+        
+        quality ||= @api_client&.default_audio_quality || "mediumQuality"
+        @audio_url_map[quality]
+      end
+
+      def thumbs_up
+        return unless @api_client && @allow_feedback
+        @api_client.add_feedback(@track_token, true)
+      end
+
+      def thumbs_down
+        return unless @api_client && @allow_feedback
+        @api_client.add_feedback(@track_token, false)
+      end
+
+      def bookmark_song
+        return unless @api_client
+        @api_client.add_song_bookmark(@track_token)
+      end
+
+      def bookmark_artist
+        return unless @api_client
+        @api_client.add_artist_bookmark(@track_token)
+      end
+
+      def sleep
+        return unless @api_client
+        @api_client.sleep_song(@track_token)
+      end
+    end
+
+    class Playlist < Collection
+      def self.from_json(api_client, data)
+        playlist = new({}, api_client)
+        playlist.populate_from_json(data)
+        
+        # Add playlist items
+        if data["items"]
+          data["items"].each do |item_data|
+            item = PlaylistItem.from_json(api_client, item_data)
+            playlist << item
+          end
+        end
+        
+        playlist
+      end
+    end
+
+    class AdItem < PlaylistItem
+      field :ad_token, "adToken"
+      field :company_name, "companyName"
+      field :title, "title"
+      field :click_through_url, "clickThroughUrl"
+      field :image_url, "imageUrl"
+      field :tracking_tokens, "trackingTokens"
+
+      attr_accessor :station_id
+
+      def initialize(data = {}, api_client = nil)
+        super(data, api_client)
+        @is_ad = true
+      end
+    end
+  end
+end

data/lib/pandoru/models/search.rb

@@ -0,0 +1,75 @@
+require_relative '_base'
+
+module Pandoru
+  module Models
+    class SearchResultItem < Base
+      field :artist_name, 'artistName'
+      field :song_name, 'songName'
+      field :music_token, 'musicToken'
+      field :score, 'score'
+      field :likely_match, 'likelyMatch', type: :boolean
+
+      def song?
+        !song_name.nil?
+      end
+
+      def artist?
+        song_name.nil?
+      end
+
+      def create_station
+        return nil unless @api_client
+        if song?
+          @api_client.create_station(song_token: music_token)
+        else
+          @api_client.create_station(artist_token: music_token)
+        end
+      end
+    end
+
+    class SearchResult < Collection
+      field :near_matches_available, 'nearMatchesAvailable', type: :boolean
+      field :explanation, 'explanation'
+
+      def self.from_json(api_client, data)
+        instance = new(data, api_client)
+        instance.populate_from_json(data)
+        
+        # Add songs
+        if data['songs']
+          SearchResultItem.from_json_list(api_client, data['songs']).each do |item|
+            instance << item
+          end
+        end
+
+        # Add artists (convert to SearchResultItem format)
+        if data['artists']
+          data['artists'].each do |artist_data|
+            item_data = {
+              'artistName' => artist_data['artistName'],
+              'musicToken' => artist_data['musicToken'],
+              'score' => artist_data['score'],
+              'likelyMatch' => artist_data['likelyMatch']
+            }
+            item = SearchResultItem.from_json(api_client, item_data)
+            instance << item
+          end
+        end
+
+        instance
+      end
+
+      def songs
+        select(&:song?)
+      end
+
+      def artists
+        select(&:artist?)
+      end
+
+      def best_match
+        max_by(&:score)
+      end
+    end
+  end
+end