sleeper_rb 0.2.0

data/lib/sleeper_rb/client.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require_relative "utilities/array_proxy"
+require_relative "utilities/cache"
+require_relative "utilities/request"
+require_relative "utilities/roster_position"
+require_relative "resources/avatar"
+require_relative "resources/draft"
+require_relative "resources/draft_array"
+require_relative "resources/league"
+require_relative "resources/league_array"
+require_relative "resources/nfl_state"
+require_relative "resources/player"
+require_relative "resources/player_array"
+require_relative "resources/traded_pick"
+require_relative "resources/traded_pick_array"
+require_relative "resources/user"
+require_relative "resources/user_array"
+
+module SleeperRb
+  ##
+  # A SleeperRb::Client instance is the interface for formulating all requests for Sleeper data.
+  class Client
+    ##
+    # Returns the current NflState.
+    #
+    # @return {SleeperRb::Resources::NflState}[rdoc-ref:SleeperRb::Resources::NflState] The NflState instance
+    def nfl_state
+      Resources::NflState.instance
+    end
+
+    ##
+    # Returns a user found by either username or user_id. Usernames are subject to change and are thus unstable.
+    #
+    # @param username [String] The current username
+    #
+    # @param user_id [String] The numerical user_id
+    #
+    # @return {SleeperRb::Resources::User}[rdoc-ref:SleeperRb::Resources::User]
+    def user(username: nil, user_id: nil)
+      Resources::User.new(username: username, user_id: user_id)
+    end
+
+    ##
+    # Returns an avatar found by the alphanumeric ID.
+    #
+    # @param avatar_id [String] The ID for the avatar
+    #
+    # @return {SleeperRb::Resources::Avatar}[rdoc-ref:SleeperRb::Resources::Avatar]
+    def avatar(avatar_id)
+      Resources::Avatar.new(avatar_id: avatar_id)
+    end
+
+    ##
+    # Returns a League found by the alphanumeric ID.
+    #
+    # @param league_id [String] The ID for the League
+    #
+    # @return {SleeperRb::Resources::League}[rdoc-ref:SleeperRb::Resources::League]
+    def league(league_id)
+      Resources::League.new(league_id: league_id)
+    end
+
+    ##
+    # Returns all NFL players.
+    #
+    # @return [{SleeperRb::Resources::PlayerArray}[rdoc-ref:SleeperRb::Resources::PlayerArray]]
+    def players
+      Resources::PlayerArray.new(Resources::Player.all)
+    end
+
+    ##
+    # Returns a specific Draft.
+    #
+    # @return [{SleeperRb::Resources::Draft}[rdoc-ref:SleeperRb::Resources::Draft]]
+    def draft(draft_id)
+      Resources::Draft.new(draft_id: draft_id)
+    end
+  end
+end

data/lib/sleeper_rb/resources/avatar.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module SleeperRb
+  module Resources
+    ##
+    # The Avatar class allows access to full-size or thumbnail URLs for user avatars.
+    class Avatar
+      include SleeperRb::Utilities::Request
+      include SleeperRb::Utilities::Cache
+
+      ##
+      # :attr_reader: avatar_id
+
+      ##
+      # :method: full_size
+      # Returns the full size image for the Avatar
+      #
+      # @return [Tempfile]
+
+      ##
+      # :method: thumbnail
+      # Returns the full size image for the Avatar
+      #
+      # @return [Tempfile]
+
+      cached_attr :full_size, :thumbnail, :avatar_id
+
+      private
+
+      def retrieve_values!
+        full_url = "#{CDN_BASE_URL}/avatars/#{avatar_id}"
+        full_file = download_file(full_url, "#{avatar_id}-full")
+        thumb_url = "#{CDN_BASE_URL}/avatars/thumbs/#{avatar_id}"
+        thumb_file = download_file(thumb_url, "#{avatar_id}-thumb")
+        {
+          full_size: full_file,
+          thumbnail: thumb_file,
+          avatar_id: avatar_id
+        }
+      end
+    end
+  end
+end

data/lib/sleeper_rb/resources/draft/metadata.rb

@@ -0,0 +1,83 @@
+# frozen-string-literal: true
+
+module SleeperRb
+  module Resources
+    class Draft
+      ##
+      # Metadata about a particular Draft.
+      class Metadata
+        include SleeperRb::Utilities::Cache
+
+        ##
+        # :attr_reader: scoring_type
+
+        ##
+        # :attr_reader: name
+
+        ##
+        # :attr_reader: description
+
+        ##
+        # :attr_reader: offering_user_id
+
+        ##
+        # :attr_reader: offering_slot
+
+        ##
+        # :attr_reader: nominating_user_id
+
+        ##
+        # :attr_reader: nominating_slot
+
+        ##
+        # :attr_reader: nominated_player_id
+
+        ##
+        # :attr_reader: hovered_player_id
+
+        ##
+        # :attr_reader: highest_offer
+
+        cached_attr :scoring_type, :name, :description, :offering_user_id, :offering_slot, :nominating_user_id,
+                    :nominating_slot, :nominated_player_id, :hovered_player_id, :highest_offer
+
+        ##
+        # :method: offering_user
+        # The user who has made the most recent offer.
+        #
+        # @return [{SleeperRb::Resources::User}[rdoc-ref:SleeperRb::Resources::User]]
+        cached_association :offering_user do
+          User.new(user_id: offering_user_id)
+        end
+
+        ##
+        # :method: nominating_user
+        # The user who has made the most recent nomination.
+        #
+        # @return [{SleeperRb::Resources::User}[rdoc-ref:SleeperRb::Resources::User]]
+        cached_association :nominating_user do
+          User.new(user_id: nominating_user_id)
+        end
+
+        ##
+        # :method: nominated_player
+        # The player who is currently nominated.
+        #
+        # @return [{SleeperRb::Resources::Player}[rdoc-ref:SleeperRb::Resources::Player]]
+        cached_association :nominated_player do
+          Player.new(player_id: nominated_player_id)
+        end
+
+        ##
+        # :method: hovered_player
+        #
+        # @return [{SleeperRb::Resources::Player}[rdoc-ref:SleeperRb::Resources::Player]]
+        cached_association :hovered_player do
+          Player.new(player_id: hovered_player_id)
+        end
+
+        skip_refresh :all
+      end
+    end
+  end
+end

data/lib/sleeper_rb/resources/draft/pick/metadata.rb

@@ -0,0 +1,64 @@
+# frozen-string-literal: true
+
+module SleeperRb
+  module Resources
+    class Draft
+      class Pick
+        ##
+        # Metadata associated with a specific draft pick.
+        class Metadata
+          include SleeperRb::Utilities::Cache
+
+          ##
+          # :attr_reader: years_exp
+
+          ##
+          # :attr_reader: team
+
+          ##
+          # :attr_reader: status
+
+          ##
+          # :attr_reader: sport
+
+          ##
+          # :attr_reader: player_id
+
+          ##
+          # :attr_reader: number
+
+          ##
+          # :attr_reader: news_updated
+
+          ##
+          # :attr_reader: last_name
+
+          ##
+          # :attr_reader: injury_status
+
+          ##
+          # :attr_reader: first_name
+
+          ##
+          # :method: position
+          #
+          # @return [{SleeperRb::Utilities::RosterPosition}[rdoc-ref:SleeperRb::Utilities::RosterPosition]]
+
+          cached_attr :years_exp, :team, :status, :sport, :player_id, :number, :last_name, :injury_status,
+                      :first_name, position: ->(position) { SleeperRb::Utilities::RosterPosition.new(position) },
+                                   news_updated: :timestamp
+
+          skip_refresh :all
+
+          ##
+          # Returns the combined first and last name.
+          #
+          # @return [String]
+          def full_name
+            [first_name, last_name].join(" ")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sleeper_rb/resources/draft/pick.rb

@@ -0,0 +1,85 @@
+# frozen-string-literal: true
+
+require_relative "pick/metadata"
+
+module SleeperRb
+  module Resources
+    class Draft
+      ##
+      # A pick from a given draft, containing information about the user and selected player.
+      class Pick
+        include SleeperRb::Utilities::Cache
+
+        ##
+        # :attr_reader: round
+
+        ##
+        # :attr_reader: roster_id
+
+        ##
+        # :attr_reader: player_id
+
+        ##
+        # :attr_reader: picked_by
+
+        ##
+        # :attr_reader: pick_no
+
+        ##
+        # :attr_reader: is_keeper
+
+        ##
+        # :attr_reader: draft_slot
+
+        ##
+        # :attr_reader: draft_id
+
+        ##
+        # :method: draft
+        # Returns the draft instance to which this pick belongs.
+        #
+        # @return [{SleeperRb::Resources::Draft}[rdoc-ref:SleeperRb::Resources::Draft]]
+
+        ##
+        # :method: metadata
+        # Returns the metadata for this pick.
+        #
+        # @return [{SleeperRb::resources::Draft::Pick::Metadata}[rdoc-ref:SleeperRb::resources::Draft::Pick::Metadata]]
+
+        cached_attr :round, :roster_id, :player_id, :picked_by, :pick_no, :is_keeper, :draft_slot, :draft_id, :draft,
+                    metadata: ->(hash) { Metadata.new(hash) }
+
+        delegate(*Metadata.cached_attrs.keys, to: :metadata)
+
+        skip_refresh :all
+
+        ##
+        # :method: player
+        # Returns the player instance selected with this pick.
+        #
+        # @return [{SleeperRb::Resources::Player}[rdoc-ref:SleeperRb::Resources::Player]]
+        cached_association :player do
+          Player.new(player_id: player_id)
+        end
+
+        ##
+        # :method: roster
+        # Returns the roster instance to which this pick belongs.
+        #
+        # @return [{SleeperRb::Resources::League::Roster}[rdoc-ref:SleeperRb::Resources::League::Roster]]
+        cached_association :roster do
+          draft.league.rosters.detect { |roster| roster.roster_id == roster_id }
+        end
+
+        ##
+        # :method: user
+        # Returns the user instance to whom this pick belongs.
+        #
+        # @return [{SleeperRb::Resources::User}[rdoc-ref:SleeperRb::Resources::User]]
+        cached_association :user do
+          draft.league.users.detect { |user| user.user_id == picked_by }
+        end
+      end
+    end
+  end
+end

data/lib/sleeper_rb/resources/draft/pick_array.rb

@@ -0,0 +1,11 @@
+# frozen-string-literal: true
+
+module SleeperRb
+  module Resources
+    class Draft
+      ##
+      # Implements {SleeperRb::Utilities::ArrayProxy} and wraps Pick objects.
+      class PickArray < SleeperRb::Utilities::ArrayProxy; end
+    end
+  end
+end

data/lib/sleeper_rb/resources/draft/settings.rb

@@ -0,0 +1,73 @@
+# frozen-string-literal: true
+
+module SleeperRb
+  module Resources
+    class Draft
+      ##
+      # Settings for a given Draft.
+      class Settings
+        include SleeperRb::Utilities::Cache
+
+        ##
+        # :attr_reader: teams
+
+        ##
+        # :attr_reader: slots_wr
+
+        ##
+        # :attr_reader: slots_te
+
+        ##
+        # :attr_reader: slots_rb
+
+        ##
+        # :attr_reader: slots_qb
+
+        ##
+        # :attr_reader: slots_k
+
+        ##
+        # :attr_reader: slots_flex
+
+        ##
+        # :attr_reader: slots_def
+
+        ##
+        # :attr_reader: slots_dbn
+
+        ##
+        # :attr_reader: rounds
+
+        ##
+        # :attr_reader: pick_time
+
+        ##
+        # :attr_reader: reversal_round
+
+        ##
+        # :attr_reader: player_type
+
+        ##
+        # :attr_reader: nomination_timer
+
+        ##
+        # :attr_reader: enforce_position_limits
+
+        ##
+        # :attr_reader: cpu_autopick
+
+        ##
+        # :attr_reader: budget
+
+        ##
+        # :attr_reader: alpha_sort
+
+        cached_attr :teams, :slots_wr, :slots_te, :slots_rb, :slots_qb, :slots_k, :slots_flex, :slots_def,
+                    :slots_bn, :rounds, :pick_timer, :reversal_round, :player_type, :nomination_timer,
+                    :enforce_position_limits, :cpu_autopick, :budget, :alpha_sort
+
+        skip_refresh :all
+      end
+    end
+  end
+end

data/lib/sleeper_rb/resources/draft.rb

@@ -0,0 +1,129 @@
+# frozen-string-literal: true
+
+require_relative "draft/metadata"
+require_relative "draft/settings"
+require_relative "draft/pick"
+require_relative "draft/pick_array"
+
+module SleeperRb
+  module Resources
+    ##
+    # Represents a draft for a given user.
+    class Draft
+      include SleeperRb::Utilities::Cache
+      include SleeperRb::Utilities::Request
+
+      ##
+      # :attr_reader: type
+
+      ##
+      # :attr_reader: status
+
+      ##
+      # :attr_reader: start_time
+
+      ##
+      # :attr_reader: sport
+
+      ##
+      # :attr_reader: season_type
+
+      ##
+      # :attr_reader: season
+
+      ##
+      # :attr_reader: league_id
+
+      ##
+      # :attr_reader: league
+
+      ##
+      # :attr_reader: last_picked
+
+      ##
+      # :attr_reader: last_message_time
+
+      ##
+      # :attr_reader: last_message_id
+
+      ##
+      # :attr_reader: draft_order
+
+      ##
+      # :attr_reader: draft_id
+
+      ##
+      # :attr_reader: creators
+
+      ##
+      # :attr_reader: created
+
+      ##
+      # :method: settings
+      # Settings for the draft.
+      #
+      # @return [{SleeperRb::Resources::Draft::Settings}[rdoc-ref:SleeperRb::Resources::Draft::Settings]]
+
+      ##
+      # :method: metadata
+      # Metadata for the draft.
+      #
+      # @return [{SleeperRb::Resources::Draft::Metadata}[rdoc-ref:SleeperRb::Resources::Draft::Metadata]]
+
+      cached_attr :type, :status, :start_time, :sport, :season_type, :season, :league_id, :last_picked, :league,
+                  :last_message_time, :last_message_id, :draft_order, :draft_id, :creators, :created, :slot_to_roster_id,
+                  settings: ->(hash) { Settings.new(hash) },
+                  metadata: ->(hash) { Metadata.new(hash) }
+
+      delegate(*Settings.cached_attrs.keys, to: :settings)
+      delegate(*Metadata.cached_attrs.keys, to: :metadata)
+
+      skip_refresh :all
+
+      ##
+      # :method: traded_picks
+      # All picks in the Draft that were traded.
+      #
+      # @return [{SleeperRb::Resources::TradedPickArray}[rdoc-ref:SleeperRb::Resources::TradedPickArray]]
+      cached_association :traded_picks do
+        retrieve_traded_picks!
+      end
+
+      ##
+      # :method: draft_picks
+      # All picks in the Draft.
+      #
+      # @return [{SleeperRb::Resources::Draft::Pick}[rdoc-ref:SleeperRb::Resources::Draft::Pick]]
+      cached_association :draft_picks do
+        retrieve_picks!
+      end
+
+      def auction?
+        type == "auction"
+      end
+
+      def snake?
+        type == "snake"
+      end
+
+      private
+
+      def retrieve_values!
+        url = "#{SleeperRb::Utilities::Request::BASE_URL}/draft/#{@draft_id}"
+        execute_request(url)
+      end
+
+      def retrieve_traded_picks!
+        url = "#{SleeperRb::Utilities::Request::BASE_URL}/draft/#{@draft_id}/traded_picks"
+        response = execute_request(url)
+        TradedPickArray.new(response.map { |hash| TradedPick.new(hash) })
+      end
+
+      def retrieve_picks!
+        url = "#{SleeperRb::Utilities::Request::BASE_URL}/draft/#{@draft_id}/picks"
+        response = execute_request(url)
+        PickArray.new(response.map { |hash| Pick.new(hash.merge(draft: self)) })
+      end
+    end
+  end
+end

data/lib/sleeper_rb/resources/draft_array.rb

@@ -0,0 +1,25 @@
+# frozen-string-literal: true
+
+module SleeperRb
+  module Resources
+    ##
+    # Implements {SleeperRb::Utilities::ArrayProxy} and wraps Draft objects.
+    class DraftArray < SleeperRb::Utilities::ArrayProxy
+      ##
+      # Returns all auction drafts.
+      #
+      # @return [{SleeperRb::Resources::DraftArray}[rdoc-ref:SleeperRb::Resources::DraftArray]]
+      def auction
+        where(auction?: true)
+      end
+
+      ##
+      # Returns all snake drafts.
+      #
+      # @return [{SleeperRb::Resources::DraftArray}[rdoc-ref:SleeperRb::Resources::DraftArray]]
+      def snake
+        where(snake?: true)
+      end
+    end
+  end
+end

data/lib/sleeper_rb/resources/league/matchup.rb

@@ -0,0 +1,66 @@
+# frozen-string-literal: true
+
+module SleeperRb
+  module Resources
+    class League
+      ##
+      # Represents a matchup for a specific team in a specific week. Two records with the same matchup_id are paired
+      # against each other.
+      class Matchup
+        include SleeperRb::Utilities::Cache
+
+        ##
+        # :attr_reader: starters_points
+
+        ##
+        # :attr_reader: roster_id
+
+        ##
+        # :attr_reader: points
+
+        ##
+        # :attr_reader: matchup_id
+
+        ##
+        # :attr_reader: custom_points
+
+        ##
+        # :method: league
+        #
+        # @return [{SleeperRb::Resources::League}[rdoc-ref:SleeperRb::Resources::League]]
+
+        ##
+        # :method: starters
+        # All players starting on the roster for this matchup.
+        #
+        # @return [{SleeperRb::Resources::Player}[rdoc-ref:SleeperRb::Resources::Player]]
+
+        ##
+        # :method: players
+        # All players on the roster for this matchup.
+        #
+        # @return [{SleeperRb::Resources::Player}[rdoc-ref:SleeperRb::Resources::Player]]
+
+        cached_attr :starters_points, :roster_id, :points, :matchup_id, :custom_points, :league,
+                    starters: ->(array) { array&.map { |id| Player.new(player_id: id) } },
+                    players: ->(array) { array&.map { |id| Player.new(player_id: id) } }
+
+        skip_refresh :all
+
+        ##
+        # :method: roster
+        #
+        # @return [{SleeperRb::Resources::League::Roster}[rdoc-ref:SleeperRb::Resources::League::Roster]]
+        cached_association :roster do
+          retrieve_roster!
+        end
+
+        private
+
+        def retrieve_roster!
+          league.rosters.detect { |roster| roster.roster_id == roster_id }
+        end
+      end
+    end
+  end
+end

data/lib/sleeper_rb/resources/league/matchup_array.rb

@@ -0,0 +1,11 @@
+# frozen-string-literal: true
+
+module SleeperRb
+  module Resources
+    class League
+      ##
+      # Implements {SleeperRb::Utilities::ArrayProxy} and wraps Matchup objects.
+      class MatchupArray < SleeperRb::Utilities::ArrayProxy; end
+    end
+  end
+end