sleeper_rb 0.2.0

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

@@ -0,0 +1,153 @@
+# frozen-string-literal: true
+
+require_relative "transaction/metadata"
+require_relative "transaction/settings"
+require_relative "transaction/waiver_budget"
+
+module SleeperRb
+  module Resources
+    class League
+      ##
+      # Represents a waiver move, free agent transaction, or trade.
+      class Transaction
+        include SleeperRb::Utilities::Cache
+
+        ##
+        # :attr_reader: transaction_id
+
+        ##
+        # :attr_reader: type
+
+        ##
+        # :attr_reader: status
+
+        ##
+        # :attr_reader: roster_ids
+
+        ##
+        # :attr_reader: week
+
+        ##
+        # :attr_reader: drops
+
+        ##
+        # :attr_reader: creator
+
+        ##
+        # :attr_reader: consenter_ids
+
+        ##
+        # :attr_reader: adds
+
+        ##
+        # :attr_reader: created
+
+        ##
+        # :attr_reader: status_updated
+
+        # rubocop:disable Layout/LineLength
+
+        ##
+        # :method: waiver_budget
+        #
+        # @return [Array<{SleeperRb::Resources::League::Transaction::WaiverBudget}[rdoc-ref:SleeperRb::Resources::League::Transaction::WaiverBudget]>]
+
+        ##
+        # :method: settings
+        #
+        # @return [{SleeperRb::Resources::League::Transaction::Settings}[rdoc-ref:SleeperRb::Resources::League::Transaction::Settings]]
+
+        ##
+        # :method: metadata
+        #
+        # @return [{SleeperRb::Resources::League::Transaction::Metadata}[rdoc-ref:SleeperRb::Resources::League::Transaction::Metadata]]
+
+        ## :method: league
+        # The league this transaction is a part of.
+        #
+        # @return [{SleeperRb::Resources::League}[rdoc-ref:SleeperRb::Resources::League]]
+
+        ##
+        # :method: draft_picks
+        # Any draft picks traded as part of this transaction.
+        #
+        # @return [{SleeperRb::Resources::TradedPickArray}[rdoc-ref:SleeperRb::Resources::TradedPickArray]]
+
+        # rubocop:enable Layout/LineLength
+
+        cached_attr :league, :transaction_id, :type, :status, :roster_ids, :leg, :drops, :creator, :consenter_ids,
+                    :adds, created: :timestamp, status_updated: :timestamp,
+                           waiver_budget: ->(array) { array&.map { |hash| WaiverBudget.new(hash.merge(transaction: self)) } },
+                           settings: ->(hash) { Settings.new(hash || {}) },
+                           metadata: ->(hash) { Metadata.new(hash || {}) },
+                           draft_picks: ->(array) { TradedPickArray.new(array&.map { |hash| TradedPick.new(hash) }) }
+
+        delegate(*Settings.cached_attrs.keys, to: :settings)
+        delegate(*Metadata.cached_attrs.keys, to: :settings)
+
+        alias week leg
+
+        skip_refresh :all
+
+        ##
+        # :method: rosters
+        # Returns rosters participating in this transaction.
+        #
+        # @return [{SleeperRb::Resources::League::RosterArray}[rdoc-ref:SleeperRb::Resources::League::RosterArray]]
+        cached_association :rosters do
+          league.rosters.where(roster_id: { in: roster_ids })
+        end
+
+        ##
+        # :method: user
+        # Returns the User who created this transaction.
+        #
+        # @return [{SleeperRb::Resources::User}[rdoc-ref:SleeperRb::Resources::User]]
+        cached_association :user do
+          league.users.detect { |user| user.user_id == creator }
+        end
+
+        ##
+        # :method: consenting_rosters
+        # Returns the rosters who consented to this transaction.
+        #
+        # @return [{SleeperRb::Resources::League::RosterArray}[rdoc-ref:SleeperRb::Resources::League::RosterArray]]
+        cached_association :consenting_rosters do
+          league.rosters.where(roster_id: { in: consenter_ids })
+        end
+
+        ##
+        # Returns true if the transaction is a trade.
+        #
+        # @return [Boolean]
+        def trade?
+          type == "trade"
+        end
+
+        ##
+        # Returns true if the transaction is for a free agent.
+        #
+        # @return [Boolean]
+        def free_agent?
+          type == "free_agent"
+        end
+
+        ##
+        # Returns true if the transaction is for a free agent acquired with FAAB.
+        #
+        # @return [Boolean]
+        def faab?
+          free_agent? && !waiver_bid.nil?
+        end
+
+        ##
+        # Returns true if the transaction is for a free agent acquired via the waiver wire.
+        #
+        # @return [Boolean]
+        def waiver?
+          free_agent? && !waiver_bid
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen-string-literal: true
+
+module SleeperRb
+  module Resources
+    class League
+      ##
+      # Implements {SleeperRb::Utilities::ArrayProxy} and wraps Transaction objects.
+      class TransactionArray < SleeperRb::Utilities::ArrayProxy
+        ##
+        # Returns transactions which are trades.
+        #
+        # @return [{SleeperRb::Resources::League::TransactionArray}[rdoc-ref:SleeperRb::Resources::League::TransactionArray]]
+        def trade
+          where(type: "trade")
+        end
+
+        ##
+        # Returns transactions which are free agent acquisitions.
+        #
+        # @return [{SleeperRb::Resources::League::TransactionArray}[rdoc-ref:SleeperRb::Resources::League::TransactionArray]]
+        def free_agent
+          where(type: "free_agent")
+        end
+
+        ##
+        # Returns transactions which are free agent acquisitions made with FAAB.
+        #
+        # @return [{SleeperRb::Resources::League::TransactionArray}[rdoc-ref:SleeperRb::Resources::League::TransactionArray]]
+        def faab
+          where(type: "free_agent", waiver_bid: { not: nil })
+        end
+
+        ##
+        # Returns transactions which are free agent acquisitions made via the waiver wire.
+        #
+        # @return [{SleeperRb::Resources::League::TransactionArray}[rdoc-ref:SleeperRb::Resources::League::TransactionArray]]
+        def waiver
+          where(type: "free_agent", waiver_bid: nil)
+        end
+      end
+    end
+  end
+end

data/lib/sleeper_rb/resources/league.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require_relative "league/matchup"
+require_relative "league/matchup_array"
+require_relative "league/roster"
+require_relative "league/roster_array"
+require_relative "league/scoring_settings"
+require_relative "league/settings"
+require_relative "league/transaction"
+require_relative "league/transaction_array"
+
+module SleeperRb
+  module Resources
+    ##
+    # This class represents a Fantasy Football League and is the access point for associated resources.
+    # All attributes are lazily loaded and cache their value based on the API response.
+    class League
+      include SleeperRb::Utilities::Request
+      include SleeperRb::Utilities::Cache
+
+      ##
+      # :attr_reader: total_rosters
+
+      ##
+      # :attr_reader: status
+
+      ##
+      # :attr_reader: sport
+
+      ##
+      # :attr_reader: season_type
+
+      ##
+      # :attr_reader: season
+
+      ##
+      # :attr_reader: previous_league_id
+
+      ##
+      # :attr_reader: name
+
+      ##
+      # :attr_reader: league_id
+
+      ##
+      # :attr_reader: draft_id
+
+      ##
+      # :method: avatar
+      # Retrieves the Avatar instance for the league.
+      #
+      # @return [{SleeperRb::Resources::Avatar}[rdoc-ref:SleeperRb::Resources::Avatar]]
+
+      ##
+      # :method: scoring_settings
+      # Retrieves the scoring settings for the league.
+      #
+      # @return [{SleeperRb::Resources::League::ScoringSettings}[rdoc-ref:SleeperRb::Resources::League::ScoringSettings]]
+
+      ##
+      # :method: roster_positions
+      # Retrieves the available roster positions for the league.
+      #
+      # @return [Array<{SleeperRb::Utilities::RosterPosition}[rdoc-ref:SleeperRb::Utilities::RosterPosition]>]
+
+      ##
+      # :method: settings
+      # Returns the non-scoring settings for the league.
+      #
+      # @return [{SleeperRb::Resources::League::Settings}[rdoc-ref:SleeperRb::Resources::League::Settings]]
+      cached_attr :total_rosters, :status, :sport, :season_type, :season, :previous_league_id, :name, :league_id,
+                  :draft_id, avatar: ->(id) { Resources::Avatar.new(avatar_id: id) },
+                             scoring_settings: ->(settings) { ScoringSettings.new(settings) },
+                             roster_positions: lambda { |array|
+                               array.map do |pos|
+                                 SleeperRb::Utilities::RosterPosition.new(pos)
+                               end
+                             },
+                             settings: ->(settings) { Settings.new(settings) }
+
+      delegate(*Settings.cached_attrs.keys, to: :settings)
+      delegate(*ScoringSettings.cached_attrs.keys, to: :scoring_settings)
+      delegate :ppr?, :half_ppr?, :standard?, to: :scoring_settings
+
+      ##
+      # :method: rosters
+      # Retrieves rosters for the League.
+      #
+      # @return [{SleeperRb::Resources::League::RosterArray}[rdoc-ref:SleeperRb::Resources::League::RosterArray]]
+      cached_association :rosters do
+        retrieve_rosters!
+      end
+
+      ##
+      # :method: users
+      # Retrieves users for the League.
+      #
+      # @return [{SleeperRb::Resources::UserArray}[rdoc-ref:SleeperRb::Resources::UserArray]]
+      cached_association :users do
+        retrieve_users!
+      end
+
+      ##
+      # :method: matchups
+      # Returns matchups for the League for the given week.
+      # :call-seq:
+      #   matchups(week_number)
+      #
+      # @return [{SleeperRb::Resources::League::MatchupArray}[rdoc-ref:SleeperRb::Resources::League::MatchupArray]]
+      cached_association :matchups do |week|
+        retrieve_matchups!(week)
+      end
+
+      ##
+      # :method: traded_picks
+      # Returns all traded draft picks for the League.
+      #
+      # @return [{SleeperRb::Resources::TradedPickArray}[rdoc-ref:SleeperRb::Resources::TradedPickArray]]
+      cached_association :traded_picks do
+        retrieve_traded_picks!
+      end
+
+      ##
+      # :method: drafts
+      # Returns all drafts for the league
+      #
+      # @return [{SleeperRb::Resources::DraftArray}[rdoc-ref:SleeperRb::Resources::DraftArray]]
+      cached_association :drafts do
+        retrieve_drafts!
+      end
+
+      ##
+      # :method: transactions
+      # Returns all transactions for the League for a given week.
+      # :call-seq:
+      #   transactions(week_number)
+      #
+      # @return [{SleeperRb::Resources::League::TransactionArray}[rdoc-ref:SleeperRb::Resources::League::TransactionArray]]
+      cached_association :transactions do |week|
+        retrieve_transactions!(week)
+      end
+
+      def initialize(opts = {})
+        raise ArgumentError unless opts[:league_id]
+
+        super
+      end
+
+      SleeperRb::Utilities::RosterPosition::VALID_ROSTER_POSITIONS.each do |pos|
+        define_method(pos) { roster_positions.select(&:"#{pos}?").size }
+      end
+
+      private
+
+      def retrieve_values!
+        url = "#{BASE_URL}/league/#{league_id}"
+        execute_request(url)
+      end
+
+      def retrieve_rosters!
+        url = "#{BASE_URL}/league/#{league_id}/rosters"
+        response = execute_request(url)
+        RosterArray.new(response.map { |hash| Roster.new(hash.merge(league: self)) })
+      end
+
+      def retrieve_users!
+        url = "#{BASE_URL}/league/#{league_id}/users"
+        response = execute_request(url)
+        UserArray.new(response.map { |hash| User.new(hash) })
+      end
+
+      def retrieve_matchups!(week)
+        url = "#{BASE_URL}/league/#{league_id}/matchups/#{week}"
+        response = execute_request(url)
+        MatchupArray.new(response.map { |hash| Matchup.new(hash.merge(league: self)) })
+      end
+
+      def retrieve_traded_picks!
+        url = "#{BASE_URL}/league/#{league_id}/traded_picks"
+        response = execute_request(url)
+        TradedPickArray.new(response.map { |hash| TradedPick.new(hash.merge(league: self)) })
+      end
+
+      def retrieve_drafts!
+        url = "#{BASE_URL}/league/#{league_id}/drafts"
+        response = execute_request(url)
+        DraftArray.new(response.map { |hash| Draft.new(hash.merge(league: self)) })
+      end
+
+      def retrieve_transactions!(week)
+        url = "#{BASE_URL}/league/#{league_id}/transactions/#{week}"
+        response = execute_request(url)
+        TransactionArray.new(response.map { |hash| Transaction.new(hash.merge(league: self)) })
+      end
+    end
+  end
+end

data/lib/sleeper_rb/resources/league_array.rb

@@ -0,0 +1,41 @@
+# frozen-string-literal: true
+
+module SleeperRb
+  module Resources
+    ##
+    # Implements {SleeperRb::Utilities::ArrayProxy}[rdoc-ref:SleeperRb::Utilities::ArrayProxy] and wraps League objects.
+    class LeagueArray < SleeperRb::Utilities::ArrayProxy
+      ##
+      # Returns leagues which are set to Best Ball mode.
+      #
+      # @return [{SleeperRb::Resources::LeagueArray}[rdoc-ref:SleeperRb::Resources::LeagueArray]]
+      def best_ball
+        where(best_ball: true)
+      end
+
+      ##
+      # Returns leagues which use PPR scoring.
+      #
+      # @return [{SleeperRb::Resources::LeagueArray}[rdoc-ref:SleeperRb::Resources::LeagueArray]]
+      def ppr
+        where(ppr?: true)
+      end
+
+      ##
+      # Returns leagues which use Half-PPR scoring.
+      #
+      # @return [{SleeperRb::Resources::LeagueArray}[rdoc-ref:SleeperRb::Resources::LeagueArray]]
+      def half_ppr
+        where(half_ppr?: true)
+      end
+
+      ##
+      # Returns leagues which use Standard (Zero PPR) scoring.
+      #
+      # @return [{SleeperRb::Resources::LeagueArray}[rdoc-ref:SleeperRb::Resources::LeagueArray]]
+      def standard
+        where(standard?: true)
+      end
+    end
+  end
+end

data/lib/sleeper_rb/resources/nfl_state.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+module SleeperRb
+  module Resources
+    ##
+    # The NflState resource represents the current state of the NFL (week number, year, etc) as defined by Sleeper.
+    class NflState
+      include Singleton
+      include SleeperRb::Utilities::Request
+      include SleeperRb::Utilities::Cache
+
+      ##
+      # :attr_reader: week
+
+      ##
+      # :attr_reader: season_type
+
+      ##
+      # :attr_reader: season
+
+      ##
+      # :attr_reader: league_season
+
+      ##
+      # :attr_reader: season_start_date
+
+      ##
+      # :attr_reader: previous_season
+
+      ##
+      # :attr_reader: leg
+
+      ##
+      # :attr_reader: league_create_season
+
+      ##
+      # :attr_reader: display_week
+
+      cached_attr :week, :season_type, :season, :league_season, :season_start_date, :previous_season,
+                  :leg, :league_create_season, :display_week
+
+      private
+
+      def retrieve_values!
+        execute_request(URI("#{BASE_URL}/state/nfl"))
+      end
+    end
+  end
+end

data/lib/sleeper_rb/resources/player.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+module SleeperRb
+  module Resources
+    ##
+    # A specific NFL player with general information about roster position, physical attributes, team, etc.
+    class Player
+      extend SleeperRb::Utilities::Request
+      include SleeperRb::Utilities::Cache
+
+      class << self
+        ##
+        # Ensuring there is one source of players so the heavy endpoint need not be called frequently.
+        #
+        # @return [{SleeperRb::Resources::PlayerArray}[rdoc-ref:SleeperRb::Resources::PlayerArray]]
+        def all
+          @all ||= PlayerArray.new(player_hashes.reduce([]) do |array, (_player_id, player_hash)|
+            array << new(player_hash)
+          end)
+        end
+
+        ##
+        # Resets the values for all players.
+        #
+        # @return [self]
+        def refresh
+          @all = nil
+          @player_hashes = nil
+          self
+        end
+
+        def player_hashes
+          @player_hashes ||= retrieve_players!
+        end
+
+        private
+
+        def retrieve_players!
+          url = "#{BASE_URL}/players/nfl"
+          execute_request(url)
+        end
+      end
+
+      ##
+      # :attr_reader: hashtag
+
+      ##
+      # :attr_reader: depth_chart_position
+
+      ##
+      # :attr_reader: status
+
+      ##
+      # :attr_reader: sport
+
+      ##
+      # :attr_reader: number
+
+      ##
+      # :attr_reader: injury_start_date
+
+      ##
+      # :attr_reader: weight
+
+      ##
+      # :attr_reader: practice_participation
+
+      ##
+      # :attr_reader: sportradar_id
+
+      ##
+      # :attr_reader: team
+
+      ##
+      # :attr_reader: last_name
+
+      ##
+      # :attr_reader: college
+
+      ##
+      # :attr_reader: fantasy_data_id
+
+      ##
+      # :attr_reader: full_name
+
+      ##
+      # :attr_reader: injury_status
+
+      ##
+      # :attr_reader: player_id
+
+      ##
+      # :attr_reader: height
+
+      ##
+      # :attr_reader: age
+
+      ##
+      # :attr_reader: stats_id
+
+      ##
+      # :attr_reader: birth_country
+
+      ##
+      # :attr_reader: espn_id
+
+      ##
+      # :attr_reader: first_name
+
+      ##
+      # :attr_reader: active
+
+      ##
+      # :attr_reader: depth_chart_order
+
+      ##
+      # :attr_reader: years_exp
+
+      ##
+      # :attr_reader: rotowire_id
+
+      ##
+      # :attr_reader: yahoo_id
+
+      ##
+      # :attr_reader: pandascore_id
+
+      ##
+      # :attr_reader: news_updated
+
+      ##
+      # :attr_reader: birth_city
+
+      ##
+      # :attr_reader: birth_date
+
+      ##
+      # :attr_reader: injury_notes
+
+      ##
+      # :attr_reader: gsis_id
+
+      ##
+      # :attr_reader: birth_state
+
+      ##
+      # :attr_reader: swish_id
+
+      ##
+      # :attr_reader: high_school
+
+      ##
+      # :attr_reader: metadata
+
+      ##
+      # :attr_reader: injury_body_part
+
+      ##
+      # :attr_reader: practice_description
+
+      ##
+      # :method: fantasy_positions
+      # All fantasy positions for which the player is eligible.
+      #
+      # @return [Array<{SleeperRb::Utilities::RosterPosition}[rdoc-ref:SleeperRb::Utilities::RosterPosition]>]
+
+      ##
+      # :method: position
+      # Primary position for the player.
+      #
+      # @return [{SleeperRb::Utilities::RosterPosition}[rdoc-ref:SleeperRb::Utilities::RosterPosition]]
+
+      cached_attr :hashtag, :depth_chart_position, :status, :sport, :number, :injury_start_date, :weight,
+                  :practice_participation, :sportradar_id, :team, :last_name, :college, :fantasy_data_id, :full_name,
+                  :injury_status, :player_id, :height, :age, :stats_id, :birth_country, :espn_id, :first_name, :active,
+                  :depth_chart_order, :years_exp, :rotowire_id, :rotoworld_id, :yahoo_id, :pandascore_id, :news_updated,
+                  :birth_city, :birth_date, :injury_notes, :gsis_id, :birth_state, :swish_id, :high_school, :metadata,
+                  :injury_body_part, :practice_description,
+                  fantasy_positions: ->(array) { array&.map { |pos| SleeperRb::Utilities::RosterPosition.new(pos) } },
+                  position: ->(pos) { pos ? SleeperRb::Utilities::RosterPosition.new(pos) : nil }
+
+      private
+
+      def retrieve_values!
+        self.class.player_hashes[@player_id.to_sym]
+      end
+    end
+  end
+end

data/lib/sleeper_rb/resources/player_array.rb

@@ -0,0 +1,16 @@
+# frozen-string-literal: true
+
+module SleeperRb
+  module Resources
+    ##
+    # Provides methods named for each valid roster position which return a PlayerArray containing all
+    # players which match the given roster position.
+    class PlayerArray < SleeperRb::Utilities::ArrayProxy
+      SleeperRb::Utilities::RosterPosition::VALID_ROSTER_POSITIONS.each do |position|
+        define_method(position) do
+          where(position: position)
+        end
+      end
+    end
+  end
+end