y_fantasy 0.1.0

data/lib/y_fantasy/resources/team.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module YFantasy
+  # Represents a fantasy team in a Yahoo Fantasy Sports league
+  class Team < BaseResource
+    # --- REQUIRED ATTRIBUTES ------------------------------------------------------------------------------------------
+
+    # @!attribute [r] team_key
+    # @return [String] the unique key for this team
+    option :team_key
+
+    # @!attribute [r] team_id
+    # @return [Integer] the ID for this team
+    option :team_id, type: Types::Coercible::Integer
+
+    # @!attribute [r] has_draft_grade
+    # @return [Boolean] whether this team has a draft grade
+    option :has_draft_grade, type: Types::Params::Bool
+
+    # @!attribute [r] league_scoring_type
+    # @return [String] the scoring type of the league (e.g. "head", "point")
+    option :league_scoring_type
+
+    # @!attribute [r] managers
+    # @return [Array<Manager>] Array of team managers
+    option :managers, type: array_of(Manager)
+
+    # @!attribute [r] name
+    # @return [String] the name of the team
+    option :name
+
+    # @!attribute [r] number_of_moves
+    # @return [Integer] the number of roster moves made by this team
+    option :number_of_moves, type: Types::Coercible::Integer
+
+    # @!attribute [r] number_of_trades
+    # @return [Integer] the number of trades made by this team
+    option :number_of_trades, type: Types::Coercible::Integer
+
+    # @!attribute [r] roster_adds
+    # @return [String] the roster adds information for this team
+    option :roster_adds
+
+    # @!attribute [r] team_logos
+    # @return [Hash] the team logo information
+    option :team_logos, type: ->(h) { h[:team_logo] }
+
+    # @!attribute [r] url
+    # @return [String] the URL to the team's Yahoo Fantasy page
+    option :url
+
+    # --- OPTIONAL ATTRIBUTES ------------------------------------------------------------------------------------------
+
+    # @!attribute [r] clinched_playoffs
+    # @return [Boolean, nil] whether this team has clinched a playoff spot
+    option :clinched_playoffs, optional: true, type: Types::Params::Bool
+
+    # @!attribute [r] division_id
+    # @return [Integer, nil] the ID of the division this team belongs to
+    option :division_id, optional: true, type: Types::Coercible::Integer
+
+    # @!attribute [r] draft_grade
+    # @return [String, nil] the grade assigned to this team's draft
+    option :draft_grade, optional: true
+
+    # @!attribute [r] draft_recap_url
+    # @return [String, nil] the URL to this team's draft recap
+    option :draft_recap_url, optional: true
+
+    # @!attribute [r] faab_balance
+    # @return [Integer, nil] the remaining Free Agent Acquisition Budget (FAAB) for this team
+    option :faab_balance, optional: true, type: Types::Coercible::Integer
+
+    # @!attribute [r] waiver_priority
+    # @return [Integer, nil] This team's waiver priority
+    option :waiver_priority, optional: true, type: Types::Coercible::Integer
+
+    # @!attribute [r] league_key
+    # @return [String, nil] the key of the league this team belongs to
+    option :league_key, optional: true
+
+    # @!attribute [r] league
+    # @return [League, nil] the league this team belongs to
+    option :league, optional: true
+
+    # --- SUBRESOURCES -------------------------------------------------------------------------------------------------
+
+    # @!attribute [r] draft_results
+    # @return [Array<DraftResult>, nil] the draft results for this team
+    option :draft_results, optional: true, type: array_of(DraftResult)
+
+    # @!attribute [r] matchups
+    # @return [Array<Matchup>] the matchups for this team
+    option :matchups, optional: true, type: array_of(Matchup), default: -> { [] }
+
+    # @!attribute [r] roster
+    # @return [Roster, nil] the roster for this team
+    option :roster, optional: true, type: instance_of(Roster)
+
+    # @!attribute [r] stats
+    # @return [StatCollection, nil] the stat collection for this team
+    option :stats, optional: true, type: instance_of(StatCollection), default: -> {}
+
+    # @!attribute [r] team_standings
+    # @return [Standings, nil] the standings for this team
+    option :team_standings, optional: true, type: instance_of(Standings)
+
+    has_subresource :draft_results, klass: DraftResult
+    has_subresource :matchups, klass: Matchup
+    has_subresource :roster, klass: Roster
+    has_subresource :stats, klass: StatCollection
+    has_subresource :team_standings, klass: Standings
+
+    def_delegators :team_standings, :rank, :playoff_seed, :wins, :losses, :ties, :points_for, :points_against
+
+    # --- INSTANCE METHODS ---------------------------------------------------------------------------------------------
+
+    # Returns the primary manager of the team
+    # @return [Manager] the primary manager (non-comanager) of the team
+    def manager
+      managers.find { |manager| !manager.is_comanager }
+    end
+
+    # Returns a hash of simplified standings information for the team
+    # @return [Hash] a hash containing key standings information
+    def simple_standings
+      {
+        team_key: team_key,
+        name: name,
+        rank: rank,
+        playoff_seed: playoff_seed,
+        wins: wins,
+        losses: losses,
+        ties: ties,
+        points_for: points_for,
+        points_against: points_against
+      }
+    end
+
+    # Returns the league key for this team
+    # @return [String] the league key
+    def league_key
+      @league_key ||= team_key.sub(/\.t\.\d+/, "")
+    end
+
+    # Returns the league this team belongs to
+    # @return [League] the league object
+    def league
+      @league ||= League.find(league_key)
+    end
+
+    # Gets the matchups for this team for a specific week
+    # @param week [Integer] the week number to get matchups for
+    # @return [Array<Matchup>] the matchups for the specified week
+    def matchups_for_week(week)
+      @matchups = self.class.find(team_key, with: :matchups, week: week).matchups
+    end
+
+    # Gets the roster for this team for a specific week
+    # @param week [Integer] the week number to get the roster for
+    # @param player_stats [Boolean] Whether to include player stats
+    # @return [Roster] the roster for the specified week
+    def roster_for_week(week, player_stats: false)
+      with = player_stats ? {roster: {players: :stats}} : :roster
+      @roster = self.class.find(team_key, with: with, week: week).roster
+    end
+
+    # Gets the stats for this team for a specific week
+    # @param week [Integer] the week number to get stats for
+    # @return [StatCollection] the stats for the specified week
+    def stats_for_week(week)
+      @stats = self.class.find(team_key, with: :stats, week: week).stats
+    end
+  end
+end

data/lib/y_fantasy/subresource_validator.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module YFantasy
+  class SubresourceValidator
+    def self.validate!(klass, subresources = [])
+      new(klass, subresources).validate!
+    end
+
+    def initialize(klass, subresources = [])
+      @contract = Contract.new(klass: klass)
+      @subresources = Array(subresources)
+    end
+
+    def validate!
+      return true if @subresources.empty?
+
+      result = @contract.call(subresources: @subresources)
+      return true if result.success?
+
+      raise InvalidSubresourceError.new(result.errors.to_h.to_s)
+    end
+
+    class Contract < Dry::Validation::Contract
+      option :klass
+
+      params do
+        required(:subresources).value(:array)
+      end
+
+      # TODO: Simplify this. It's gotten too complicated.
+      rule(:subresources).each do
+        fail_msg = "#{value} is not a valid subresource of #{klass}"
+        next key.failure(fail_msg) unless value.is_a?(Symbol) || value.is_a?(Hash)
+
+        if value.is_a?(Symbol)
+          next if klass.subresource_tree.key?(value)
+
+          key.failure(fail_msg)
+        elsif value.is_a?(Hash)
+          if value.keys.size > 1
+            next key.failure("Nested subresources should contain a single top-level key. Found: #{value.keys}")
+          end
+
+          sub, nested_subs = value.keys.first, value.values
+          valid_nested_subs = klass.subresource_tree.dig(sub)
+          next key.failure(fail_msg) if !valid_nested_subs
+
+          nested_subs.each do |nested_sub|
+            if nested_sub.is_a?(Hash)
+              nested_klass = YFantasy.const_get(Transformations::T.singularize(nested_sub.keys.first).capitalize)
+              next if SubresourceValidator.new(nested_klass, Array(nested_sub.values.first))
+            end
+
+            next if valid_nested_subs.include?(nested_sub)
+            key.failure("#{nested_sub} is not a valid subresource of #{sub}")
+          end
+        end
+      end
+    end
+
+    class InvalidSubresourceError < StandardError
+      def initialize(msg = "Invalid subresource(s)")
+        super
+      end
+    end
+  end
+end

data/lib/y_fantasy/transformations/base_transform.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module YFantasy
+  module Transformations
+    # Base class for all transformations in the YFantasy module.
+    #
+    # @abstract Subclasses must set @function instance variable
+    # @example Creating a custom transformation
+    #   class MyTransform < BaseTransform
+    #     def initialize(param)
+    #       @function = ->(data) { transform_data(data, param) }
+    #     end
+    #
+    #     private
+    #
+    #     def transform_data(data, param)
+    #       # transformation logic here
+    #     end
+    #   end
+    class BaseTransform
+      extend Forwardable
+
+      # Delegates transformation-related methods to the @function object
+      # @!method >>(other)
+      #   Function composition - chains this transformation with another
+      #   @param other [#call] Another callable object to compose with
+      #   @return [Proc] A new composed function
+      # @!method call(*args)
+      #   Invokes the transformation function
+      #   @param args Arguments to pass to the transformation
+      #   @return [Object] The transformed result
+      # @!method [](*args)
+      #   Alias for call
+      #   @param args Arguments to pass to the transformation
+      #   @return [Object] The transformed result
+      def_delegators :@function, :>>, :call, :[]
+
+      # Initializes a new transformation instance
+      # @param args [Array] Arguments for initialization (used by subclasses)
+      # @raise [RuntimeError] If @function is not properly set by the subclass
+      def initialize(*args)
+        ensure_function_set
+      end
+
+      # Helper method to call transformations provided by Dry::Transformer (see T module)
+      # @param args [Array] Arguments to pass to Dry::Transformer
+      # @return [Object] A new transformation object
+      def t(*args)
+        T[*args]
+      end
+
+      # Ensures that the transformation function is properly set
+      # @raise [RuntimeError] If @function is not callable or does not respond to the required methods
+      # @return [nil] if the function is properly set
+      def ensure_function_set
+        return if @function.respond_to?(:>>) && @function.respond_to?(:call)
+
+        raise "Subclass must set @function instance variable"
+      end
+    end
+  end
+end

data/lib/y_fantasy/transformations/collection_transformer.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module YFantasy
+  module Transformations
+    class CollectionTransformer < BaseTransform
+      def initialize(collection)
+        @collection = collection.to_sym
+        @resource = T[:singularize].call(collection).to_sym
+        @function = compose_function
+      end
+
+      private
+
+      def compose_function
+        UserTransformer.new
+          .>> t(:dig_value, @collection, @resource)
+          .>> t(:wrap_in_array)
+          .>> t(:map_array, Transformations.transformer_for(@resource))
+      end
+    end
+  end
+end

data/lib/y_fantasy/transformations/default_transformer.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module YFantasy
+  module Transformations
+    class DefaultTransformer < BaseTransform
+      def initialize(resource)
+        @resource = resource
+        @function = compose_function
+        super
+      end
+
+      private
+
+      def compose_function
+        plural = t(:pluralize, @resource).call.to_sym
+        singular = t(:singularize, @resource).call.to_sym
+
+        t(:guard, t(:dig_value, plural, singular), t(:map_value, plural, t(:dig_value, singular)))
+      end
+    end
+  end
+end

data/lib/y_fantasy/transformations/game/position_types_transformer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module YFantasy
+  module Transformations
+    module Game
+      class PositionTypesTransformer < BaseTransform
+        def initialize
+          @function = compose_function
+          super
+        end
+
+        private
+
+        def compose_function
+          fn = DefaultTransformer.new(:position_types) >> t(:map_value, :position_types, t(:wrap_in_array))
+          t(:guard, ->(data) { data.key?(:position_types) }, fn)
+        end
+      end
+    end
+  end
+end

data/lib/y_fantasy/transformations/game_transformer.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module YFantasy
+  module Transformations
+    class GameTransformer < BaseTransform
+      def initialize
+        @function = compose_function
+        super
+      end
+
+      private
+
+      def compose_function
+        t(:guard, ->(data) { data.key?(:game) }, t(:unwrap, :game))
+          .>> transform_game_weeks
+          .>> transform_groups
+          .>> transform_leagues
+          .>> transform_position_types
+          .>> transform_roster_positions
+          .>> transform_stat_categories
+          .>> Instantiator.new(YFantasy::Game)
+      end
+
+      def transform_game_weeks
+        DefaultTransformer.new(:game_weeks)
+      end
+
+      def transform_groups
+        map_groups_fn = t(:map_array, Transformations.group_transformer(nested: true))
+        # wrap_in_array is needed when there is only 1 group
+        fn = DefaultTransformer.new(:groups) >> t(:map_value, :groups, t(:wrap_in_array) >> map_groups_fn)
+        t(:guard, ->(data) { !data[:groups].nil? }, fn)
+      end
+
+      def transform_leagues
+        map_leagues_fn = t(:map_array, Transformations.league_transformer(nested: true))
+        fn = DefaultTransformer.new(:leagues) >> t(:map_value, :leagues, t(:wrap_in_array) >> map_leagues_fn)
+        t(:guard, ->(data) { !data[:leagues].nil? }, fn)
+      end
+
+      def transform_position_types
+        Game::PositionTypesTransformer.new
+      end
+
+      def transform_roster_positions
+        DefaultTransformer.new(:roster_positions)
+      end
+
+      def transform_stat_categories
+        StatCategoriesTransformer.new
+      end
+    end
+  end
+end

data/lib/y_fantasy/transformations/group_transformer.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module YFantasy
+  module Transformations
+    class GroupTransformer < BaseTransform
+      def initialize(nested: false)
+        @nested = nested
+        @function = compose_function
+        super
+      end
+
+      private
+
+      def compose_function
+        t(:guard, ->(data) { data.key?(:group) }, t(:unwrap, :group))
+          .>> transform_teams
+          .>> transform_standings
+          .>> instantiate
+      end
+
+      def transform_teams
+        DefaultTransformer.new(:teams) >> t(:map_value, :teams, map_teams_fn)
+      end
+
+      def transform_standings
+        map_standings_fn = t(:map_value, :standings, t(:rename_keys, team: :teams) >> t(:map_value, :teams, map_teams_fn))
+        t(:guard, ->(data) { data.key?(:standings) }, map_standings_fn)
+      end
+
+      def map_teams_fn
+        t(:map_array, Transformations.pickem_team_transformer(nested: true))
+      end
+
+      def instantiate
+        @nested ? t(:no_op) : Instantiator.new(YFantasy::Group)
+      end
+    end
+  end
+end

data/lib/y_fantasy/transformations/instantiator.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module YFantasy
+  module Transformations
+    class Instantiator < BaseTransform
+      def initialize(klass, collection: false)
+        @klass = klass
+        @collection = collection
+        @function = compose_function
+        super(klass)
+      end
+
+      private
+
+      def compose_function
+        fn = t(->(data) { data.is_a?(Hash) ? @klass.new(**data) : data })
+        for_collection? ? t(:map_array, fn) : fn
+      end
+
+      def for_collection?
+        @collection
+      end
+    end
+  end
+end

data/lib/y_fantasy/transformations/key_unwrapper.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module YFantasy
+  module Transformations
+    class KeyUnwrapper < BaseTransform
+      def initialize(*keys)
+        @function = keys.map { |key| t(:unwrap, key) }.inject(:>>)
+        super
+      end
+    end
+  end
+end

data/lib/y_fantasy/transformations/league/scoreboard_transformer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module YFantasy
+  module Transformations
+    module League
+      class ScoreboardTransformer < BaseTransform
+        def initialize
+          @function = compose_function
+          super
+        end
+
+        private
+
+        def compose_function
+          fn = t(:map_value, :scoreboard, MatchupsTransformer.new)
+          t(:guard, ->(data) { data.key?(:scoreboard) }, fn)
+        end
+      end
+    end
+  end
+end

data/lib/y_fantasy/transformations/league/settings_transformer.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module YFantasy
+  module Transformations
+    module League
+      class SettingsTransformer < BaseTransform
+        def initialize
+          @function = compose_function
+          super
+        end
+
+        private
+
+        def compose_function
+          fn = t(
+            :map_value,
+            :settings,
+            DefaultTransformer.new(:roster_positions) >> StatCategoriesTransformer.new >> StatModifiersTransformer.new
+          )
+          t(:guard, ->(data) { data.key?(:settings) }, fn)
+        end
+      end
+    end
+  end
+end

data/lib/y_fantasy/transformations/league/standings_transformer.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module YFantasy
+  module Transformations
+    module League
+      class StandingsTransformer < BaseTransform
+        def initialize
+          @function = compose_function
+          super
+        end
+
+        private
+
+        def compose_function
+          map_teams_fn = t(:map_array, Transformations.team_transformer(nested: true))
+          map_standings_fn = t(:map_value, :standings, DefaultTransformer.new(:teams) >> t(:map_value, :teams, map_teams_fn))
+          t(:guard, ->(data) { data.key?(:standings) }, map_standings_fn)
+        end
+      end
+    end
+  end
+end

data/lib/y_fantasy/transformations/league_transformer.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module YFantasy
+  module Transformations
+    class LeagueTransformer < BaseTransform
+      def initialize(nested: false)
+        @nested = nested
+        @function = compose_function
+        super
+      end
+
+      private
+
+      def compose_function
+        t(:guard, ->(data) { data.key?(:league) }, t(:unwrap, :league))
+          .>> transform_draft_results
+          .>> transform_scoreboard
+          .>> transform_settings
+          .>> transform_standings
+          .>> transform_players
+          .>> transform_teams
+          .>> instantiate
+      end
+
+      def transform_draft_results
+        DefaultTransformer.new(:draft_results)
+      end
+
+      def transform_scoreboard
+        League::ScoreboardTransformer.new
+      end
+
+      def transform_settings
+        League::SettingsTransformer.new
+      end
+
+      def transform_standings
+        League::StandingsTransformer.new
+      end
+
+      def transform_players
+        map_players_fn = t(:map_array, Transformations.player_transformer(nested: true))
+        DefaultTransformer.new(:players) >> t(:map_value, :players, map_players_fn)
+      end
+
+      def transform_teams
+        map_teams_fn = t(:map_array, Transformations.team_transformer(nested: true))
+        # wrap_in_array is needed when there is only 1 team. This can happen when requesting data scoped to current user.
+        DefaultTransformer.new(:teams) >> t(:map_value, :teams, t(:wrap_in_array) >> map_teams_fn)
+      end
+
+      def instantiate
+        @nested ? t(:no_op) : Instantiator.new(YFantasy::League)
+      end
+    end
+  end
+end

data/lib/y_fantasy/transformations/matchups_transformer.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module YFantasy
+  module Transformations
+    class MatchupsTransformer < BaseTransform
+      def initialize
+        @function = compose_function
+        super
+      end
+
+      private
+
+      def compose_function
+        map_teams_fn = t(:map_array, Transformations.team_transformer(nested: true))
+        map_matchups_fn = t(:map_array, DefaultTransformer.new(:teams) >> t(:map_value, :teams, map_teams_fn))
+        # wrap_in_array is needed when requesting a team's matchup for a single week
+        fn = DefaultTransformer.new(:matchups) >> t(:map_value, :matchups, t(:wrap_in_array) >> map_matchups_fn)
+        t(:guard, ->(data) { !data[:matchups].nil? }, fn)
+      end
+    end
+  end
+end

data/lib/y_fantasy/transformations/pickem_team/week_picks_transformer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module YFantasy
+  module Transformations
+    module PickemTeam
+      class WeekPicksTransformer < BaseTransform
+        def initialize
+          @function = compose_function
+          super
+        end
+
+        private
+
+        def compose_function
+          t(:guard, ->(data) { data.key?(:week_picks) }, transform_week_picks)
+        end
+
+        def transform_week_picks
+          map_week_picks_fn = t(:map_array, transform_picks)
+          DefaultTransformer.new(:week_picks) >> t(:map_value, :week_picks, map_week_picks_fn)
+        end
+
+        def transform_picks
+          DefaultTransformer.new(:picks) >> t(:map_value, :picks, t(:wrap_in_array))
+        end
+      end
+    end
+  end
+end