rockbox 0.1.0

data/lib/rockbox/api/library.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require_relative "../types"
+
+module Rockbox
+  module Api
+    class Library
+      TRACK_FIELDS = <<~GQL
+        fragment TrackFields on Track {
+          id title artist album genre disc trackString yearString
+          composer comment albumArtist grouping
+          discnum tracknum layer year bitrate frequency
+          filesize length elapsed path
+          albumId artistId genreId albumArt
+        }
+      GQL
+
+      ALBUM_FIELDS = <<~GQL
+        fragment AlbumFields on Album {
+          id title artist year yearString albumArt md5 artistId copyrightMessage
+        }
+      GQL
+
+      ARTIST_FIELDS = <<~GQL
+        fragment ArtistFields on Artist { id name bio image }
+      GQL
+
+      def initialize(http)
+        @http = http
+      end
+
+      # ---------------------------------------------------------------------
+      # Albums
+      # ---------------------------------------------------------------------
+
+      def albums
+        data = @http.execute(<<~GQL)
+          #{ALBUM_FIELDS}
+          query Albums { albums { ...AlbumFields tracks { id title path length albumArt } } }
+        GQL
+        Array(data[:albums]).map { |a| Album.from_hash(a) }
+      end
+
+      def album(id)
+        data = @http.execute(<<~GQL, { id: id })
+          #{TRACK_FIELDS}
+          #{ALBUM_FIELDS}
+          query Album($id: String!) { album(id: $id) { ...AlbumFields tracks { ...TrackFields } } }
+        GQL
+        Album.from_hash(data[:album])
+      end
+
+      def liked_albums
+        data = @http.execute("#{ALBUM_FIELDS}\nquery LikedAlbums { likedAlbums { ...AlbumFields } }")
+        Array(data[:liked_albums]).map { |a| Album.from_hash(a) }
+      end
+
+      def like_album(id)
+        @http.execute("mutation LikeAlbum($id: String!) { likeAlbum(id: $id) }", { id: id })
+        nil
+      end
+
+      def unlike_album(id)
+        @http.execute("mutation UnlikeAlbum($id: String!) { unlikeAlbum(id: $id) }", { id: id })
+        nil
+      end
+
+      # ---------------------------------------------------------------------
+      # Artists
+      # ---------------------------------------------------------------------
+
+      def artists
+        data = @http.execute(<<~GQL)
+          #{ARTIST_FIELDS}
+          query Artists { artists { ...ArtistFields albums { id title albumArt year } } }
+        GQL
+        Array(data[:artists]).map { |a| Artist.from_hash(a) }
+      end
+
+      def artist(id)
+        data = @http.execute(<<~GQL, { id: id })
+          #{ARTIST_FIELDS}
+          #{TRACK_FIELDS}
+          query Artist($id: String!) {
+            artist(id: $id) {
+              ...ArtistFields
+              albums { id title albumArt year yearString md5 artistId tracks { id title path length } }
+              tracks { ...TrackFields }
+            }
+          }
+        GQL
+        Artist.from_hash(data[:artist])
+      end
+
+      # ---------------------------------------------------------------------
+      # Tracks
+      # ---------------------------------------------------------------------
+
+      def tracks
+        data = @http.execute("#{TRACK_FIELDS}\nquery Tracks { tracks { ...TrackFields } }")
+        Array(data[:tracks]).map { |t| Track.from_hash(t) }
+      end
+
+      def track(id)
+        data = @http.execute(
+          "#{TRACK_FIELDS}\nquery Track($id: String!) { track(id: $id) { ...TrackFields } }",
+          { id: id }
+        )
+        Track.from_hash(data[:track])
+      end
+
+      def liked_tracks
+        data = @http.execute("#{TRACK_FIELDS}\nquery LikedTracks { likedTracks { ...TrackFields } }")
+        Array(data[:liked_tracks]).map { |t| Track.from_hash(t) }
+      end
+
+      def like_track(id)
+        @http.execute("mutation LikeTrack($id: String!) { likeTrack(id: $id) }", { id: id })
+        nil
+      end
+
+      def unlike_track(id)
+        @http.execute("mutation UnlikeTrack($id: String!) { unlikeTrack(id: $id) }", { id: id })
+        nil
+      end
+
+      # ---------------------------------------------------------------------
+      # Search
+      # ---------------------------------------------------------------------
+
+      # @return [Rockbox::SearchResults]
+      def search(term)
+        data = @http.execute(<<~GQL, { term: term })
+          #{TRACK_FIELDS}
+          #{ALBUM_FIELDS}
+          #{ARTIST_FIELDS}
+          query Search($term: String!) {
+            search(term: $term) {
+              artists { ...ArtistFields }
+              albums { ...AlbumFields }
+              tracks { ...TrackFields }
+              likedTracks { ...TrackFields }
+              likedAlbums { ...AlbumFields }
+            }
+          }
+        GQL
+        results = data[:search] || {}
+        SearchResults.new(
+          artists:      Array(results[:artists]).map      { |a| Artist.from_hash(a) },
+          albums:       Array(results[:albums]).map       { |a| Album.from_hash(a) },
+          tracks:       Array(results[:tracks]).map       { |t| Track.from_hash(t) },
+          liked_tracks: Array(results[:liked_tracks]).map { |t| Track.from_hash(t) },
+          liked_albums: Array(results[:liked_albums]).map { |a| Album.from_hash(a) }
+        )
+      end
+
+      # ---------------------------------------------------------------------
+      # Library management
+      # ---------------------------------------------------------------------
+
+      def scan
+        @http.execute("mutation ScanLibrary { scanLibrary }")
+        nil
+      end
+    end
+  end
+end

data/lib/rockbox/api/playback.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require_relative "../types"
+
+module Rockbox
+  module Api
+    class Playback
+      TRACK_FIELDS = <<~GQL
+        fragment TrackFields on Track {
+          id title artist album genre disc trackString yearString
+          composer comment albumArtist grouping
+          discnum tracknum layer year bitrate frequency
+          filesize length elapsed path
+          albumId artistId genreId albumArt
+        }
+      GQL
+
+      def initialize(http)
+        @http = http
+      end
+
+      # ---------------------------------------------------------------------
+      # Status & current track
+      # ---------------------------------------------------------------------
+
+      # @return [Integer] one of {Rockbox::PlaybackStatus} constants.
+      def status
+        @http.execute("query PlaybackStatus { status }")[:status]
+      end
+
+      # @return [Symbol] :stopped | :playing | :paused | :unknown
+      def status_name
+        PlaybackStatus.name(status)
+      end
+
+      # @return [Rockbox::Track, nil]
+      def current_track
+        data = @http.execute("#{TRACK_FIELDS}\nquery CurrentTrack { currentTrack { ...TrackFields } }")
+        Track.from_hash(data[:current_track])
+      end
+
+      # @return [Rockbox::Track, nil]
+      def next_track
+        data = @http.execute("#{TRACK_FIELDS}\nquery NextTrack { nextTrack { ...TrackFields } }")
+        Track.from_hash(data[:next_track])
+      end
+
+      # @return [Integer]
+      def file_position
+        @http.execute("query FilePosition { getFilePosition }")[:get_file_position]
+      end
+
+      # ---------------------------------------------------------------------
+      # Transport controls
+      # ---------------------------------------------------------------------
+
+      def play(elapsed: 0, offset: 0)
+        @http.execute(
+          "mutation Play($elapsed: Long!, $offset: Long!) { play(elapsed: $elapsed, offset: $offset) }",
+          { elapsed: elapsed, offset: offset }
+        )
+        nil
+      end
+
+      def pause;            @http.execute("mutation Pause { pause }");                            nil; end
+      def resume;           @http.execute("mutation Resume { resume }");                          nil; end
+      def next!;            @http.execute("mutation Next { next }");                              nil; end
+      def previous!;        @http.execute("mutation Previous { previous }");                      nil; end
+      def stop;             @http.execute("mutation Stop { hardStop }");                          nil; end
+      def flush_and_reload; @http.execute("mutation FlushReload { flushAndReloadTracks }");       nil; end
+
+      # @param position_ms [Integer] absolute target position, in milliseconds.
+      def seek(position_ms)
+        @http.execute(
+          "mutation Seek($newTime: Int!) { fastForwardRewind(newTime: $newTime) }",
+          { new_time: position_ms }
+        )
+        nil
+      end
+
+      # ---------------------------------------------------------------------
+      # Single-call play helpers
+      # ---------------------------------------------------------------------
+
+      def play_track(path)
+        @http.execute(
+          "mutation PlayTrack($path: String!) { playTrack(path: $path) }",
+          { path: path }
+        )
+        nil
+      end
+
+      def play_album(album_id, shuffle: nil, position: nil)
+        @http.execute(
+          "mutation PlayAlbum($albumId: String!, $shuffle: Boolean, $position: Int) { " \
+          "playAlbum(albumId: $albumId, shuffle: $shuffle, position: $position) }",
+          { album_id: album_id, shuffle: shuffle, position: position }.compact
+        )
+        nil
+      end
+
+      def play_artist(artist_id, shuffle: nil, position: nil)
+        @http.execute(
+          "mutation PlayArtist($artistId: String!, $shuffle: Boolean, $position: Int) { " \
+          "playArtistTracks(artistId: $artistId, shuffle: $shuffle, position: $position) }",
+          { artist_id: artist_id, shuffle: shuffle, position: position }.compact
+        )
+        nil
+      end
+
+      def play_playlist(playlist_id, shuffle: nil, position: nil)
+        @http.execute(
+          "mutation PlayPlaylist($playlistId: String!, $shuffle: Boolean, $position: Int) { " \
+          "playPlaylist(playlistId: $playlistId, shuffle: $shuffle, position: $position) }",
+          { playlist_id: playlist_id, shuffle: shuffle, position: position }.compact
+        )
+        nil
+      end
+
+      def play_directory(path, recurse: nil, shuffle: nil, position: nil)
+        @http.execute(
+          "mutation PlayDirectory($path: String!, $recurse: Boolean, $shuffle: Boolean, $position: Int) { " \
+          "playDirectory(path: $path, recurse: $recurse, shuffle: $shuffle, position: $position) }",
+          { path: path, recurse: recurse, shuffle: shuffle, position: position }.compact
+        )
+        nil
+      end
+
+      def play_liked_tracks(shuffle: nil, position: nil)
+        @http.execute(
+          "mutation PlayLikedTracks($shuffle: Boolean, $position: Int) { " \
+          "playLikedTracks(shuffle: $shuffle, position: $position) }",
+          { shuffle: shuffle, position: position }.compact
+        )
+        nil
+      end
+
+      def play_all_tracks(shuffle: nil, position: nil)
+        @http.execute(
+          "mutation PlayAllTracks($shuffle: Boolean, $position: Int) { " \
+          "playAllTracks(shuffle: $shuffle, position: $position) }",
+          { shuffle: shuffle, position: position }.compact
+        )
+        nil
+      end
+    end
+  end
+end

data/lib/rockbox/api/playlist.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require_relative "../types"
+
+module Rockbox
+  module Api
+    class Playlist
+      TRACK_FIELDS = <<~GQL
+        fragment TrackFields on Track {
+          id title artist album genre disc trackString yearString
+          composer comment albumArtist grouping
+          discnum tracknum layer year bitrate frequency
+          filesize length elapsed path
+          albumId artistId genreId albumArt
+        }
+      GQL
+
+      def initialize(http)
+        @http = http
+      end
+
+      # @return [Rockbox::Playlist]
+      def current
+        data = @http.execute(<<~GQL)
+          #{TRACK_FIELDS}
+          query CurrentPlaylist {
+            playlistGetCurrent {
+              amount index maxPlaylistSize firstIndex
+              lastInsertPos seed lastShuffledStart
+              tracks { ...TrackFields }
+            }
+          }
+        GQL
+        pl = data[:playlist_get_current] || {}
+        Rockbox::Playlist.new(
+          amount:              pl[:amount],
+          index:               pl[:index],
+          max_playlist_size:   pl[:max_playlist_size],
+          first_index:         pl[:first_index],
+          last_insert_pos:     pl[:last_insert_pos],
+          seed:                pl[:seed],
+          last_shuffled_start: pl[:last_shuffled_start],
+          tracks:              Array(pl[:tracks]).map { |t| Track.from_hash(t) }
+        )
+      end
+
+      def amount
+        @http.execute("query PlaylistAmount { playlistAmount }")[:playlist_amount]
+      end
+
+      # ---------------------------------------------------------------------
+      # Queue management
+      # ---------------------------------------------------------------------
+
+      # @param paths       [Array<String>] file paths or track IDs to insert.
+      # @param position    [Integer] one of {Rockbox::InsertPosition} (default: NEXT).
+      # @param playlist_id [String, nil] target playlist; nil for the active queue.
+      def insert_tracks(paths, position: InsertPosition::NEXT, playlist_id: nil)
+        @http.execute(
+          "mutation InsertTracks($playlistId: String, $position: Int!, $tracks: [String!]!) { " \
+          "insertTracks(playlistId: $playlistId, position: $position, tracks: $tracks) }",
+          { playlist_id: playlist_id, position: position, tracks: paths }
+        )
+        nil
+      end
+
+      def insert_directory(directory, position: InsertPosition::LAST, playlist_id: nil)
+        @http.execute(
+          "mutation InsertDirectory($playlistId: String, $position: Int!, $directory: String!) { " \
+          "insertDirectory(playlistId: $playlistId, position: $position, directory: $directory) }",
+          { playlist_id: playlist_id, position: position, directory: directory }
+        )
+        nil
+      end
+
+      def insert_album(album_id, position: InsertPosition::LAST)
+        @http.execute(
+          "mutation InsertAlbum($albumId: String!, $position: Int!) { " \
+          "insertAlbum(albumId: $albumId, position: $position) }",
+          { album_id: album_id, position: position }
+        )
+        nil
+      end
+
+      def remove_track(index)
+        @http.execute(
+          "mutation RemoveTrack($index: Int!) { playlistRemoveTrack(index: $index) }",
+          { index: index }
+        )
+        nil
+      end
+
+      def clear
+        @http.execute("mutation ClearPlaylist { playlistRemoveAllTracks }")
+        nil
+      end
+
+      def shuffle
+        @http.execute("mutation ShufflePlaylist { shufflePlaylist }")
+        nil
+      end
+
+      def create(name, tracks)
+        @http.execute(
+          "mutation CreatePlaylist($name: String!, $tracks: [String!]!) { " \
+          "playlistCreate(name: $name, tracks: $tracks) }",
+          { name: name, tracks: tracks }
+        )
+        nil
+      end
+
+      def start(start_index: nil, elapsed: nil, offset: nil)
+        @http.execute(
+          "mutation PlaylistStart($startIndex: Int, $elapsed: Int, $offset: Int) { " \
+          "playlistStart(startIndex: $startIndex, elapsed: $elapsed, offset: $offset) }",
+          { start_index: start_index, elapsed: elapsed, offset: offset }.compact
+        )
+        nil
+      end
+
+      def resume
+        @http.execute("mutation PlaylistResume { playlistResume }")
+        nil
+      end
+    end
+  end
+end

data/lib/rockbox/api/saved_playlists.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require_relative "../types"
+
+module Rockbox
+  module Api
+    class SavedPlaylists
+      def initialize(http)
+        @http = http
+      end
+
+      def list(folder_id: nil)
+        data = @http.execute(
+          "query SavedPlaylists($folderId: String) { " \
+          "savedPlaylists(folderId: $folderId) { id name description image folderId trackCount createdAt updatedAt } }",
+          { folder_id: folder_id }.compact
+        )
+        Array(data[:saved_playlists]).map { |p| SavedPlaylist.from_hash(p) }
+      end
+
+      def get(id)
+        data = @http.execute(
+          "query SavedPlaylist($id: String!) { " \
+          "savedPlaylist(id: $id) { id name description image folderId trackCount createdAt updatedAt } }",
+          { id: id }
+        )
+        SavedPlaylist.from_hash(data[:saved_playlist])
+      end
+
+      def track_ids(playlist_id)
+        @http.execute(
+          "query SavedPlaylistTrackIds($playlistId: String!) { savedPlaylistTrackIds(playlistId: $playlistId) }",
+          { playlist_id: playlist_id }
+        )[:saved_playlist_track_ids] || []
+      end
+
+      # @example Builder-friendly
+      #   client.saved_playlists.create(name: "Late nights") do |p|
+      #     p.description = "After-dark vibes"
+      #     p.track_ids = ["abc", "def"]
+      #   end
+      def create(name:, description: nil, image: nil, folder_id: nil, track_ids: nil)
+        builder = CreateBuilder.new(name, description, image, folder_id, track_ids)
+        yield builder if block_given?
+
+        data = @http.execute(<<~GQL, builder.to_variables)
+          mutation CreateSavedPlaylist(
+            $name: String!, $description: String, $image: String,
+            $folderId: String, $trackIds: [String!]
+          ) {
+            createSavedPlaylist(
+              name: $name, description: $description, image: $image,
+              folderId: $folderId, trackIds: $trackIds
+            ) {
+              id name description image folderId trackCount createdAt updatedAt
+            }
+          }
+        GQL
+        SavedPlaylist.from_hash(data[:create_saved_playlist])
+      end
+
+      # @example
+      #   client.saved_playlists.update("pl_123", name: "Renamed")
+      def update(id, name:, description: nil, image: nil, folder_id: nil)
+        @http.execute(<<~GQL, { id: id, name: name, description: description, image: image, folder_id: folder_id }.compact)
+          mutation UpdateSavedPlaylist(
+            $id: String!, $name: String!, $description: String,
+            $image: String, $folderId: String
+          ) {
+            updateSavedPlaylist(
+              id: $id, name: $name, description: $description,
+              image: $image, folderId: $folderId
+            )
+          }
+        GQL
+        nil
+      end
+
+      def delete(id)
+        @http.execute(
+          "mutation DeleteSavedPlaylist($id: String!) { deleteSavedPlaylist(id: $id) }",
+          { id: id }
+        )
+        nil
+      end
+
+      def add_tracks(playlist_id, track_ids)
+        @http.execute(
+          "mutation AddTracksToSavedPlaylist($playlistId: String!, $trackIds: [String!]!) { " \
+          "addTracksToSavedPlaylist(playlistId: $playlistId, trackIds: $trackIds) }",
+          { playlist_id: playlist_id, track_ids: track_ids }
+        )
+        nil
+      end
+
+      def remove_track(playlist_id, track_id)
+        @http.execute(
+          "mutation RemoveTrackFromSavedPlaylist($playlistId: String!, $trackId: String!) { " \
+          "removeTrackFromSavedPlaylist(playlistId: $playlistId, trackId: $trackId) }",
+          { playlist_id: playlist_id, track_id: track_id }
+        )
+        nil
+      end
+
+      def play(playlist_id)
+        @http.execute(
+          "mutation PlaySavedPlaylist($playlistId: String!) { playSavedPlaylist(playlistId: $playlistId) }",
+          { playlist_id: playlist_id }
+        )
+        nil
+      end
+
+      # ---------------------------------------------------------------------
+      # Folders
+      # ---------------------------------------------------------------------
+
+      def folders
+        data = @http.execute("query PlaylistFolders { playlistFolders { id name createdAt updatedAt } }")
+        Array(data[:playlist_folders]).map { |f| SavedPlaylistFolder.from_hash(f) }
+      end
+
+      def create_folder(name)
+        data = @http.execute(
+          "mutation CreatePlaylistFolder($name: String!) { " \
+          "createPlaylistFolder(name: $name) { id name createdAt updatedAt } }",
+          { name: name }
+        )
+        SavedPlaylistFolder.from_hash(data[:create_playlist_folder])
+      end
+
+      def delete_folder(id)
+        @http.execute(
+          "mutation DeletePlaylistFolder($id: String!) { deletePlaylistFolder(id: $id) }",
+          { id: id }
+        )
+        nil
+      end
+
+      # Builder for #create — supports the optional yield-block DSL.
+      class CreateBuilder
+        attr_accessor :name, :description, :image, :folder_id, :track_ids
+
+        def initialize(name, description, image, folder_id, track_ids)
+          @name = name
+          @description = description
+          @image = image
+          @folder_id = folder_id
+          @track_ids = track_ids
+        end
+
+        def to_variables
+          {
+            name: name,
+            description: description,
+            image: image,
+            folder_id: folder_id,
+            track_ids: track_ids
+          }.compact
+        end
+      end
+    end
+  end
+end