radio5 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: edd4e5e61372538e86183d4e6171031695c51379482a619eb29c0b94378906e9
+  data.tar.gz: d25d7a72fdb56988bb4ae585a986671a395da01476fffa24f2ddb25d152fb85d
+SHA512:
+  metadata.gz: 94aeac4d8c3d39c751c22f5104c4f08fffa41c48f74db24f5ac984ee4f10d1f372f2bed4e361230a59f0791884adada50fa690bb8a42b523384a8ab6801f9622
+  data.tar.gz: 21475735cdf9bfc455c8a8841cdead2ab67b2e6e25503daf04c7fdd71eb32ce62f9cb8161a2c3a2f214a1365149efc4ea0711f58488fc8cdb64f74ebb52aeb3b

data/CHANGELOG.md

@@ -0,0 +1,4 @@
+0.1.0
+----------
+
+- Initial release!

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Dmytro Horoshko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,256 @@
+# Radio5
+
+[![Build](https://github.com/ocvit/radio5/workflows/Build/badge.svg)](https://github.com/ocvit/radio5/actions)
+[![Coverage Status](https://coveralls.io/repos/github/ocvit/radio5/badge.svg?branch=main)](https://coveralls.io/github/ocvit/radio5?branch=main)
+
+Adapter for [Radiooooo](https://radiooooo.com/) private API.
+
+For music exploration purposes only 🧐
+
+## TL;DR
+
+It turned out that 95% of all functionality doesn't even require an account (I'm not even talking about premium one), so here we go.
+
+## Installation
+
+Install the gem and add to Gemfile:
+
+```sh
+bundle add radio5
+```
+
+Or install it manually:
+
+```sh
+gem install radio5
+```
+
+## Configuration
+
+Create a client:
+
+```ruby
+client = Radio5::Client.new
+```
+
+You can pass additional HTTP configration if needed:
+
+```ruby
+client = Radio5::Client.new(
+  open_timeout: 30, # default: 10
+  read_timeout: 30, # default: 10
+  write_timeout: 30, # default: 10
+  proxy_url: "http://user:pass@123.4.56.178:80", # default: nil
+  debug_output: $stdout # default: nil
+)
+```
+
+## Usage
+
+To get random track:
+
+```ruby
+client.random_track
+# => {
+#   id: "655f7bb24b0d722a021a2cf2",
+#   uuid: <uuid>,
+#   artist: "Kaye Ballard",
+#   title: "In Other Words (Fly Me to the Moon)",
+#   album: "In Other Words / Lazy Afternoon",
+#   year: "1954",
+#   label: "Decca",
+#   songwriter: "Bart Howard",
+#   length: 133,
+#   info: "It is the original recording of Fly me to the moon !",
+#   cover_url: "https://asset.radiooooo.com/cover/USA/1950/large/<uuid>_1.jpg",
+#   audio: {
+#     mpeg: {
+#       url: "https://radiooooo-track.b-cdn.net/USA/1950/<uuid>.mp3?token=<token>&expires=1704717060",
+#       expires_at: 2024-01-08 12:31:00 UTC
+#     },
+#     ogg: {
+#       url: "https://radiooooo-track.b-cdn.net/USA/1950/<uuid>.ogg?token=<token>&expires=1704717060",
+#       expires_at: 2024-01-08 12:31:00 UTC
+#     }
+#   },
+#   decade: 1950,
+#   mood: :slow,
+#   country: "USA",
+#   like_count: 3,
+#   created_at: nil,
+#   created_by: "655ec7fce03fdc024c70f698"
+# }
+#
+# NOTES:
+# - `created_at` - always nil here (API limitations), available via `#track` if needed
+# - `created_by` - `id` of user who uploaded this track
+```
+
+To get random track using additional filters:
+
+```ruby
+# with country
+client.random_track(country: "FRA")
+
+# with decade(s)
+client.random_track(decades: [1960, 2000])
+
+# with mood(s)
+client.random_track(moods: [:slow, :weird])
+
+# with everything together
+client.random_track(country: "SWE", decades: [1940, 1980, 2010], moods: [:slow, :fast])
+
+# in case no tracks match the filters
+client.random_track(country: "KN1", decades: [1940], moods: [:weird])
+# => nil
+```
+
+To get information about specific track using its `id`:
+
+```ruby
+client.track("655f7bb24b0d722a021a2cf2")
+# => {
+#   ...
+#   created_at: 2023-11-23 16:20:02.283 UTC
+# }
+#
+# output is exactly the same as from `#random_track`, but `created_at` is now filled
+```
+
+OK, what input parameters are available?
+
+```ruby
+# list of countries + additional info:
+#   - `exist` - "is it still around" flag
+#   - `rank`  - subjective ranking provided by the website, only 10 countries have it
+client.countries
+# => {
+#   "AFG" => {name: "Afganistan", exist: true, rank: nil},
+#   "CBE" => {name: "Belgian Congo", exist: false, rank: nil},
+#   "FRA" => {name: "France", exist: true, rank: 2},
+#   ...
+# }
+
+# decades
+client.decades
+# => [1900, 1910, 1920, ..., 2010, 2020]
+
+# moods
+client.moods
+# => [:fast, :slow, :weird]
+#
+# NOTE: by default all 3 moods are used in `#random_track` and `#island_track`
+```
+
+It's also possible to get all valid `country`/`decade`/`moods` combinations in advance:
+
+```ruby
+# grouped by country
+client.countries_for_decade(1960)
+# => {
+#   "THA" => [:fast, :slow, :weird],
+#   "TWN" => [:fast, :slow, :weird],
+#   "EST" => [:fast, :slow],
+#   "ALB" => [:fast, :slow],
+#   "NZL" => [:fast, :slow],
+#   ...
+# }
+
+# grouped by mood
+client.countries_for_decade(1960, group_by: :mood)
+# => {
+#   slow: ["FRA", "THA", "ALB", "GRC", "IRL", ...],
+#   fast: ["THA", "TWN", "EST", "ALB", "NZL", ...],
+#   weird: ["AZE", "POL", "IRN", "YUG", "DAH", ...]
+# }
+```
+
+How to work with the "islands" ("playlists" in the simple words):
+
+```ruby
+# list all islands
+client.islands
+# => [{
+#   id: "5d330a3e06fb03d8872a3316",
+#   uuid: <uuid>,
+#   api_id: <api_id>,
+#   name: "Intimacy",
+#   info: "To get Laid. Slow to start. Fast to go further. Weird when nothing works.",
+#   category: "thematic",
+#   favourite_count: 1,
+#   play_count: 783339,
+#   rank: 17,
+#   icon_url: "https://asset.radiooooo.com/island/icon/<uuid>_2.svg",
+#   splash_url: "https://asset.radiooooo.com/island/splash/<uuid>_13.svg",
+#   marker_url: "https://asset.radiooooo.com/island/marker/<uuid>_9.svg",
+#   enabled: true,
+#   free: false,
+#   on_map: false,
+#   random: false,
+#   play_mode: "RANDOM",
+#   created_at: 2016-02-12 16:31:00 UTC,
+#   created_by: "5d3306de06fb03d8871fd119",
+#   updated_at: 2023-02-17 15:54:09.806 UTC,
+#   updated_by: "5d3306de06fb03d8871fd119"
+# }, ...]
+#
+# NOTES:
+#   - `api_id`     - have no idea where it is used
+#   - `rank`       - 1..160, not unique, can be nil
+#   - `enabled`    - is it searchable via web app, doesn't matter in our case ^^
+#   - `free`       - do you need premium account to listen to it, doesn't matter ^^
+#   - `on_map`     - is it displayed on a global map currently
+#   - `random`     - there is only one playlist with `true` and it's called "Shuffle";
+#                    basically the same as `#random_track` with no filters
+#   - `play_mode`  - it is somehow used in a web app
+#   - `created_by` - `id` of user who created this island
+#   - `updated_by` - ...and who updated it last time
+
+# to get random track from selected island
+client.island_track(island_id: "5d330a3e06fb03d8872a3316")
+
+# it's also possible to specify moods
+client.island_track(island_id: "5d330a3e06fb03d8872a3316", moods: [:fast, :weird])
+```
+
+User endpoints - WIP.
+
+## Auth?
+
+There is just a couple of features that require login and/or premium account:
+
+- history of "listened" tracks - track becomes "listened" when you got it via `#random_track` or `#island_track` (free)
+- `followed` flag for `#user` - indicates whether or not you follow this user (free)
+- `#user_liked_tracks` - list of tracks which user really rock'n'roll'ed to (free)
+- ability to use multiple countries as a filter in `#random_track` (premium)
+
+Currently auth is in a WIP state.
+
+## TODO
+
+- [x] HTTP client (no external deps, net/http hardcore only)  
+- [x] Basic API client (no auth)  
+- [x] Countries support  
+- [x] Islands support  
+- [x] Tracks support  
+- [ ] Users support  
+- [ ] Auth + auth'ed endpoints  
+
+## Development
+
+```sh
+bin/setup     // install deps
+bin/console   // interactive prompt to play around
+rake spec     // test!
+rake rubocop  // lint!
+sudo rm -rf / // relax, just kidding ^^
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ocvit/radio5.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/radio5/api.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Radio5
+  class Api
+    class Error < StandardError; end
+    class TrackNotFound < Error; end
+    class MatchingTrackNotFound < Error; end
+    class UnexpectedResponse < StandardError; end
+
+    HOST = "radiooooo.com"
+    PORT = 443
+
+    attr_reader :client
+
+    def initialize(client:)
+      @client = client
+    end
+
+    def get(path, query_params: {}, headers: {})
+      request(Net::HTTP::Get, path, query_params, nil, headers)
+    end
+
+    def post(path, query_params: {}, body: nil, headers: {})
+      request(Net::HTTP::Post, path, query_params, body, headers)
+    end
+
+    private
+
+    def request(http_method_class, path, query_params, body, headers)
+      http = create_http
+      response = http.request(http_method_class, path, query_params, body, headers)
+
+      case response.code
+      when "200", "400"
+        json = Utils.parse_json(response.body)
+
+        case json
+        in error: "No track with this id"
+          raise TrackNotFound
+        in error: "No track for this selection"
+          raise MatchingTrackNotFound
+        in error: other_error
+          raise Error, other_error
+        else
+          [response, json]
+        end
+      else
+        raise UnexpectedResponse, "code: #{response.code.inspect}, body: #{response.body.inspect}"
+      end
+    end
+
+    # rubocop:disable Layout/HashAlignment
+    def create_http
+      Http.new(
+        host:          HOST,
+        port:          PORT,
+        open_timeout:  client.open_timeout,
+        read_timeout:  client.read_timeout,
+        write_timeout: client.write_timeout,
+        proxy_url:     client.proxy_url,
+        debug_output:  client.debug_output
+      )
+    end
+    # rubocop:enable Layout/HashAlignment
+  end
+end

data/lib/radio5/client/countries.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Radio5
+  class Client
+    module Countries
+      def countries
+        _, json = api.get("/language/countries/en.json")
+
+        json.each_with_object({}) do |(iso_code, name, exist, rank), countries|
+          countries[iso_code] = {
+            name: name,
+            exist: exist,
+            rank: rank
+          }
+        end
+      end
+
+      def countries_for_decade(decade, group_by: :country)
+        validate_decade!(decade)
+
+        # optimization to avoid doing this inside `case` to save HTTP request
+        unless [:mood, :country].include?(group_by)
+          raise ArgumentError, "invalid `group_by` value: #{group_by.inspect}"
+        end
+
+        _, json = api.get("/country/mood", query_params: {decade: decade})
+
+        grouped_by_mood = json.transform_keys do |mood_upcased|
+          mood = mood_upcased.downcase
+
+          validate_mood!(mood)
+
+          mood
+        end
+
+        case group_by
+        when :mood
+          grouped_by_mood
+        when :country
+          grouped_by_country = Hash.new { |hash, country| hash[country] = [] }
+
+          MOODS.each_with_object(grouped_by_country) do |mood, grouped_by_country|
+            grouped_by_mood[mood].each do |country|
+              grouped_by_country[country] << mood
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/radio5/client/islands.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Radio5
+  class Client
+    module Islands
+      include Utils
+
+      # rubocop:disable Layout/HashAlignment
+      def islands
+        _, json = api.get("/island/all")
+
+        json.map do |island|
+          rank_value = island[:sort]
+          rank = rank_value if rank_value.is_a?(Integer)
+
+          created_at = parse_time_string(island.fetch(:created).fetch(:date))
+          created_by = island.fetch(:created).fetch(:user_id)
+
+          updated_node = island[:modified]
+          updated_at = updated_node && parse_time_string(updated_node.fetch(:date))
+          updated_by = updated_node&.fetch(:user_id)
+
+          {
+            id:              island.fetch(:_id),
+            uuid:            island.fetch(:uuid),
+            api_id:          island[:apiid],
+            name:            normalize_string(island.fetch(:name)),
+            info:            normalize_string(island[:info]),
+            category:        normalize_string(island[:category]),
+            favourite_count: island[:favorites],
+            play_count:      island.fetch(:plays),
+            rank:            rank,
+            icon_url:        parse_asset_url(island, :icon),
+            splash_url:      parse_asset_url(island, :splash),
+            marker_url:      parse_asset_url(island, :marker),
+            enabled:         island.fetch(:enabled),
+            free:            island[:free],
+            on_map:          island.fetch(:onmap),
+            random:          island.fetch(:random),
+            play_mode:       island[:play],
+            created_at:      created_at,
+            created_by:      created_by,
+            updated_at:      updated_at,
+            updated_by:      updated_by
+          }
+        end
+      end
+      # rubocop:enable Layout/HashAlignment
+    end
+  end
+end

data/lib/radio5/client/tracks.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Radio5
+  class Client
+    module Tracks
+      def track(track_id)
+        validate_track_id!(track_id)
+
+        _, json = api.get("/track/play/#{track_id}")
+
+        Parser.track_info(json)
+      rescue Api::TrackNotFound
+        nil
+      end
+
+      # TODO: technically, API accepts an array of countries, but without premium
+      # account only the first one is used during filtering.
+      # `country` should be used for now
+      # `countries` might be added in a future after implementation of auth
+
+      # rubocop:disable Layout/HashAlignment
+      def random_track(country: nil, decades: [], moods: MOODS)
+        iso_codes = country ? [country] : []
+
+        validate_country_iso_codes!(iso_codes)
+        validate_decades!(decades)
+        validate_moods!(moods)
+
+        body = {
+          mode:     "explore",
+          isocodes: iso_codes,
+          decades:  decades.uniq,
+          moods:    stringify_moods(moods).uniq
+        }.to_json
+
+        _, json = api.post("/play", body: body)
+
+        Parser.track_info(json)
+      rescue Api::MatchingTrackNotFound
+        nil
+      end
+      # rubocop:enable Layout/HashAlignment
+
+      # rubocop:disable Layout/HashAlignment
+      def island_track(island_id:, moods: MOODS)
+        validate_island_id!(island_id)
+        validate_moods!(moods)
+
+        body = {
+          mode:   "islands",
+          island: island_id,
+          moods:  stringify_moods(moods).uniq
+        }.to_json
+
+        _, json = api.post("/play", body: body)
+
+        Parser.track_info(json)
+      rescue Api::MatchingTrackNotFound
+        nil
+      end
+      # rubocop:enable Layout/HashAlignment
+
+      module Parser
+        extend Utils
+
+        # rubocop:disable Layout/HashAlignment
+        def self.track_info(json)
+          created_node = json[:created]
+          created_at = created_node && parse_time_string(created_node.fetch(:date))
+          created_by = created_node ? created_node.fetch(:user_id) : json.fetch(:profile_id)
+
+          audio = {
+            mpeg: track_audio(json, :mpeg),
+            ogg:  track_audio(json, :ogg)
+          }
+
+          {
+            id:          json.fetch(:_id),
+            uuid:        json.fetch(:uuid),
+            artist:      normalize_string(json.fetch(:artist)),
+            title:       normalize_string(json.fetch(:title)),
+            album:       normalize_string(json[:album]),
+            year:        normalize_string(json.fetch(:year)),
+            label:       normalize_string(json[:label]),
+            songwriter:  normalize_string(json[:songwriter]),
+            length:      json.fetch(:length),
+            info:        normalize_string(json[:info]),
+            cover_url:   parse_asset_url(json, :image, size: "large"),
+            audio:       audio,
+            decade:      json.fetch(:decade),
+            mood:        symbolize_mood(json.fetch(:mood)),
+            country:     json.fetch(:country),
+            like_count:  json.fetch(:likes),
+            created_at:  created_at,
+            created_by:  created_by
+          }
+        end
+        # rubocop:enable Layout/HashAlignment
+
+        def self.track_audio(json, format)
+          url = json.fetch(:links).fetch(format)
+          url.gsub!(/#t=\d*,\d+/, "")
+
+          expires_at_unix = Integer(url[/(?<=expires=)\d+/])
+          expires_at = parse_unix_timestamp(expires_at_unix)
+
+          {
+            url: url,
+            expires_at: expires_at
+          }
+        end
+      end
+      private_constant :Parser
+    end
+  end
+end

data/lib/radio5/client/users.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Radio5
+  class Client
+    module Users
+      def user
+        # ...
+      end
+    end
+  end
+end

data/lib/radio5/client.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Radio5
+  class Client
+    include Utils
+    include Validator
+    include Users
+    include Countries
+    include Islands
+    include Tracks
+
+    attr_accessor :open_timeout, :read_timeout, :write_timeout, :proxy_url, :debug_output
+
+    def initialize(open_timeout: nil, read_timeout: nil, write_timeout: nil, proxy_url: nil, debug_output: nil)
+      @open_timeout = open_timeout
+      @read_timeout = read_timeout
+      @write_timeout = write_timeout
+      @proxy_url = proxy_url
+      @debug_output = debug_output
+    end
+
+    def api
+      @api ||= Api.new(client: self)
+    end
+
+    def decades
+      DECADES
+    end
+
+    def moods
+      MOODS
+    end
+  end
+end

data/lib/radio5/http.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "openssl"
+require "uri"
+
+module Radio5
+  class Http
+    DEFAULT_OPEN_TIMEOUT = 10 # seconds
+    DEFAULT_READ_TIMEOUT = 10 # seconds
+    DEFAULT_WRITE_TIMEOUT = 10 # seconds
+    DEFAULT_DEBUG_OUTPUT = File.open(File::NULL, "w")
+    DEFAULT_MAX_RETRIES = 3
+    DEFAULT_HEADERS = {
+      "Content-Type" => "application/json; charset=utf-8",
+      "User-Agent" => "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+    }
+    RETRIABLE_ERRORS = [
+      Errno::ECONNREFUSED,
+      Errno::ECONNRESET,
+      Errno::ETIMEDOUT,
+      Net::OpenTimeout,
+      Net::ReadTimeout,
+      Net::WriteTimeout,
+      OpenSSL::SSL::SSLError
+    ]
+
+    attr_reader :max_retries
+
+    # rubocop:disable Layout/ExtraSpacing
+    def initialize(
+      host:,
+      port:,
+      open_timeout: DEFAULT_OPEN_TIMEOUT,
+      read_timeout: DEFAULT_READ_TIMEOUT,
+      write_timeout: DEFAULT_WRITE_TIMEOUT,
+      proxy_url: nil,
+      max_retries: DEFAULT_MAX_RETRIES,
+      debug_output: DEFAULT_DEBUG_OUTPUT
+    )
+      # @host          = host
+      # @port          = port
+      # @open_timeout  = open_timeout
+      # @read_timeout  = read_timeout
+      # @write_timeout = write_timeout
+      # @proxy_url     = proxy_url
+      # @debug_output  = debug_output
+
+      proxy_uri = parse_proxy_uri(proxy_url)
+      @max_retries = max_retries
+
+      @http = Net::HTTP.new(host, port, proxy_uri&.host, proxy_uri&.port, proxy_uri&.user, proxy_uri&.pass)
+
+      @http.tap do |c|
+        c.use_ssl       = port == 443
+        c.open_timeout  = open_timeout
+        c.read_timeout  = read_timeout
+        c.write_timeout = write_timeout
+
+        c.set_debug_output(debug_output)
+      end
+    end
+    # rubocop:enable Layout/ExtraSpacing
+
+    def request(http_method_class, path, query_params, body, headers)
+      request = build_request(http_method_class, path, query_params, body, headers)
+      make_request(request)
+    end
+
+    private
+
+    def parse_proxy_uri(proxy_url)
+      return if proxy_url.nil?
+
+      proxy_uri = URI(proxy_url)
+
+      unless @proxy_uri.is_a?(URI::HTTP)
+        raise ArgumentError, "Invalid proxy URL: #{@proxy_uri}"
+      end
+
+      proxy_uri
+    end
+
+    def build_request(http_method_class, path, query_params, body, headers)
+      path = add_query_params(path, query_params)
+
+      request = http_method_class.new(path)
+      add_body(request, body)
+      add_headers(request, headers)
+
+      request
+    end
+
+    def add_query_params(path, query_params)
+      if query_params.empty?
+        path
+      else
+        "#{path}?#{URI.encode_www_form(query_params)}"
+      end
+    end
+
+    def add_body(request, body)
+      request.body = body
+    end
+
+    def add_headers(request, headers)
+      DEFAULT_HEADERS.merge(headers).each do |key, value|
+        request.delete(key)
+        request.add_field(key, value)
+      end
+    end
+
+    def make_request(request, retries: 0)
+      @http.request(request)
+    rescue *RETRIABLE_ERRORS => error
+      if retries < max_retries
+        make_request(request, retries: retries + 1)
+      else
+        raise error
+      end
+    end
+  end
+end

data/lib/radio5/regexps.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Radio5
+  module Regexps
+    # rubocop:disable Layout/ExtraSpacing
+
+    MONGO_ID     = /^[a-f\d]{24}$/
+    UUID_GENERIC = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/
+    UUID         = /^#{UUID_GENERIC}$/
+
+    COUNTRY_ISO_CODE_GENERIC = /([A-Z]{3}|KN1)/
+    COUNTRY_ISO_CODE         = /^#{COUNTRY_ISO_CODE_GENERIC}$/
+
+    ASSET_URL = lambda do |sub_path, exts|
+      asset_host = Regexp.escape(Utils::ASSET_HOST)
+      sub_path   = sub_path.is_a?(Regexp) ? sub_path : Regexp.escape(sub_path)
+      exts       = /(#{exts.join("|")})/
+
+      /#{asset_host}#{sub_path}\/#{UUID_GENERIC}(_\d+)?\.#{exts}/
+    end
+
+    ISLAND_ICON_URL   = ASSET_URL.call("/island/icon", ["png", "svg"])
+    ISLAND_SPLASH_URL = ASSET_URL.call("/island/splash", ["png", "svg"])
+    ISLAND_MARKER_URL = ASSET_URL.call("/island/marker", ["png", "svg"])
+    TRACK_COVER_URL   = ASSET_URL.call(/\/cover\/#{COUNTRY_ISO_CODE_GENERIC}\/\d{4}\/large/, ["jpg", "jpeg"])
+
+    AUDIO_URL = lambda do |exts|
+      exts = /(#{exts.join("|")})/
+
+      /.+\/#{UUID_GENERIC}\.#{exts}\?token=[^&]{22}&expires=\d{10}$/
+    end
+
+    MPEG_URL = AUDIO_URL.call(["mp3", "m4a"])
+    OGG_URL  = AUDIO_URL.call(["ogg"])
+
+    # rubocop:enable Layout/ExtraSpacing
+  end
+end

data/lib/radio5/utils.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+
+module Radio5
+  module Utils
+    module_function
+
+    ASSET_HOST = "https://asset.radiooooo.com"
+
+    def parse_json(json_raw)
+      JSON.parse(json_raw, symbolize_names: true)
+    end
+
+    def parse_asset_url(hash, key, size: nil)
+      node = hash[key]
+
+      if node
+        path, filename = node.fetch_values(:path, :filename)
+        path << "#{size}/" if size
+
+        create_asset_url(path, filename)
+      end
+    end
+
+    def create_asset_url(path, filename)
+      URI.join(ASSET_HOST, path, filename).to_s
+    end
+
+    def parse_time_string(time_string)
+      Time.parse(time_string).utc
+    end
+
+    def parse_unix_timestamp(ts)
+      Time.at(ts).utc
+    end
+
+    def normalize_string(string)
+      return if string.nil? || string.empty?
+
+      normalized = string.strip
+      normalized unless normalized.empty?
+    end
+
+    def stringify_moods(moods)
+      moods.map { |mood| MOODS_MAPPING.fetch(mood) }
+    end
+
+    def symbolize_mood(mood)
+      MOODS_MAPPING.key(mood)
+    end
+  end
+end

data/lib/radio5/validator.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Radio5
+  module Validator
+    module_function
+
+    def mongo_id?(object)
+      object.is_a?(String) && object.match?(Regexps::MONGO_ID)
+    end
+
+    def country_iso_code?(object)
+      object.is_a?(String) && object.match?(Regexps::COUNTRY_ISO_CODE)
+    end
+
+    def decade?(object)
+      object.is_a?(Integer) && DECADES.include?(object)
+    end
+
+    def mood?(object)
+      object.is_a?(Symbol) && MOODS_MAPPING.key?(object)
+    end
+
+    def validate_track_id!(object)
+      unless mongo_id?(object)
+        raise ArgumentError, "invalid track ID: #{object.inspect}"
+      end
+    end
+
+    def validate_island_id!(object)
+      unless mongo_id?(object)
+        raise ArgumentError, "invalid island ID: #{object.inspect}"
+      end
+    end
+
+    def validate_country_iso_codes!(iso_codes)
+      unless iso_codes.is_a?(Array)
+        raise ArgumentError, "country ISO codes should be an array"
+      end
+
+      iso_codes.each do |iso_code|
+        validate_country_iso_code!(iso_code)
+      end
+    end
+
+    def validate_country_iso_code!(object)
+      unless country_iso_code?(object)
+        raise ArgumentError, "invalid country ISO code: #{object.inspect}"
+      end
+    end
+
+    def validate_decades!(decades)
+      unless decades.is_a?(Array)
+        raise ArgumentError, "decades should be an array"
+      end
+
+      decades.each do |decade|
+        validate_decade!(decade)
+      end
+    end
+
+    def validate_decade!(object)
+      unless decade?(object)
+        raise ArgumentError, "invalid decade: #{object.inspect}"
+      end
+    end
+
+    def validate_moods!(moods)
+      unless moods.is_a?(Array)
+        raise ArgumentError, "moods should be an array"
+      end
+
+      moods.each do |mood|
+        validate_mood!(mood)
+      end
+    end
+
+    def validate_mood!(object)
+      unless mood?(object)
+        raise ArgumentError, "invalid mood: #{object.inspect}"
+      end
+    end
+  end
+end

data/lib/radio5/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Radio5
+  VERSION = "0.1.0"
+end

data/lib/radio5.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "radio5/version"
+require_relative "radio5/utils"
+require_relative "radio5/http"
+require_relative "radio5/api"
+require_relative "radio5/regexps"
+require_relative "radio5/validator"
+require_relative "radio5/client/users"
+require_relative "radio5/client/countries"
+require_relative "radio5/client/islands"
+require_relative "radio5/client/tracks"
+require_relative "radio5/client"
+
+module Radio5
+  DECADES = (1900..2020).step(10).to_a.freeze
+
+  MOODS_MAPPING = {
+    fast: "FAST",
+    slow: "SLOW",
+    weird: "WEIRD"
+  }.freeze
+
+  MOODS = MOODS_MAPPING.keys.freeze
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: radio5
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dmytro Horoshko
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-01-08 00:00:00.000000000 Z
+dependencies: []
+description: Adapter for Radiooooo.com private API.
+email:
+- electric.molfar@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/radio5.rb
+- lib/radio5/api.rb
+- lib/radio5/client.rb
+- lib/radio5/client/countries.rb
+- lib/radio5/client/islands.rb
+- lib/radio5/client/tracks.rb
+- lib/radio5/client/users.rb
+- lib/radio5/http.rb
+- lib/radio5/regexps.rb
+- lib/radio5/utils.rb
+- lib/radio5/validator.rb
+- lib/radio5/version.rb
+homepage: https://github.com/ocvit/radio5
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/ocvit/radio5/issues
+  changelog_uri: https://github.com/ocvit/radio5/blob/main/CHANGELOG.md
+  homepage_uri: https://github.com/ocvit/radio5
+  source_code_uri: https://github.com/ocvit/radio5
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: Radiooooo.com unlocked!
+test_files: []