y_fantasy 0.1.0

data/lib/y_fantasy/api/subresource_param_builder.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module YFantasy
+  module Api
+    class SubresourceParamBuilder
+      SUBRESOURCE_MAP = {
+        draft_results: :draftresults,
+        ownership_percentage: :percent_owned,
+        team_standings: :standings
+      }
+
+      PLAYER_FILTERS = [
+        :count,
+        :position,
+        :search,
+        :sort,
+        :sort_type,
+        :start,
+        :status
+      ].freeze
+
+      def initialize(subresources = [], **options)
+        @regular_subs, @nested_subs = normalize_subresources(subresources)
+        @week = options.delete(:week)
+        @player_filters = set_player_filters(options)
+        @options = options
+      end
+
+      def build
+        @params = +""
+        add_regular_subresource_segments
+        add_nested_subresource_segments
+        add_subresource_keys
+        add_week
+        add_player_filters
+        @params
+      end
+
+      private
+
+      def add_regular_subresource_segments
+        return if @regular_subs.none?
+
+        if @regular_subs.one? && @nested_subs.none?
+          @params.concat("/#{@regular_subs.first}")
+        elsif @regular_subs.size > 1 && @regular_subs.include?(:players) && !@player_filters.empty?
+          non_player_subs = @regular_subs.select { |sub| sub != :players }
+          @params.concat(";out=#{non_player_subs.join(",")}").concat("/players")
+        else
+          @params.concat(";out=#{@regular_subs.join(",")}")
+        end
+      end
+
+      def add_nested_subresource_segments
+        return if @nested_subs.none?
+
+        if @nested_subs.one?
+          key = @nested_subs.first.keys.first
+          val = @nested_subs.first[key]
+
+          @params.concat("/#{key}")
+          @params.concat("/#{val}") if val.is_a?(Symbol)
+          @params.concat("/#{val.keys.first}/#{val.values.first}") if val.is_a?(Hash)
+          @params.concat(";out=#{val.join(",")}") if val.is_a?(Array)
+        else
+          raise self.class::Error.new("Not possible to construct a URL with 2+ sets of nested subresources: #{@nested_subs}")
+        end
+      end
+
+      def add_subresource_keys
+        return unless options_include_subresource_keys?
+
+        @options.each_pair do |k, v|
+          k_str = Transformations::T.pluralize(k.to_s.sub("_keys", ""))
+          if @params.include?("/#{k_str}")
+            @params.sub!(k_str, "#{k_str};#{k}=#{v.join(",")}")
+          end
+        end
+      end
+
+      def options_include_subresource_keys?
+        @options.keys.map(&:to_s).any? { |s| s.end_with?("_keys") }
+      end
+
+      def add_week
+        return if @week.nil?
+
+        case @params
+        when /\/(roster|scoreboard)/
+          @params.sub!(/\/(?<res>roster|scoreboard)/, "/\\k<res>;week=#{@week}")
+        when /\/matchups/
+          @params.sub!("matchups", "matchups;weeks=#{@week}")
+        when /\/stats/
+          @params.sub!("stats", "stats;type=week;week=#{@week}")
+        end
+      end
+
+      def add_player_filters
+        return if @player_filters.empty? || !@params.match?(/players/)
+
+        player_params = +""
+        @player_filters.each { |k, v| player_params.concat(k.to_s, "=", v.to_s, ";") }
+        player_params.slice!(-1)
+        @params.sub!("players", "players;#{player_params}")
+      end
+
+      def set_player_filters(options)
+        options.each_with_object({}) do |(k, v), h|
+          h[k] = v if PLAYER_FILTERS.include?(k)
+        end
+      end
+
+      def normalize_subresources(subs)
+        @regular_subs = []
+        @nested_subs = []
+
+        subs.each do |sub|
+          if sub.is_a?(Symbol)
+            @regular_subs << (SUBRESOURCE_MAP[sub] || sub)
+          end
+
+          if sub.is_a?(Hash)
+            sub.each_pair do |key, nested_subs|
+              nested_subs = Transformations::T.wrap_in_array(nested_subs)
+              nested_subs = nested_subs.map { |nested_sub| SUBRESOURCE_MAP[nested_sub] || nested_sub }
+              @nested_subs << (nested_subs.one? ? {key => nested_subs.first} : {key => nested_subs})
+            end
+          end
+        end
+
+        [@regular_subs, @nested_subs]
+      end
+
+      class Error < StandardError
+      end
+    end
+  end
+end

data/lib/y_fantasy/api/url_builder.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module YFantasy
+  module Api
+    class UrlBuilder
+      # NOTE: Could also make an id_params method and use it like `league_ids=`
+      # Key example (game_id.l (for league).league_id): <league_key>79.l.31399</league_key>
+      # ID example (last part of key) <league_id>31399</league_id>
+      # valid urls:
+      #   /games;game_keys=79/leagues;league_keys=79.l.31399
+      #   /games;game_keys=79/leagues;league_ids=31399
+      #   /game/79/leagues;league_keys=79.l.31399
+      #   /game/79/leagues;league_ids=31399
+
+      # invalid urls:
+      #   /games;game_keys=79/league/31399
+      #   /games;game_keys=79/league/79.l.31399
+      #   /game/79/league/79.l.31399
+      #   /game/79/league/31399
+
+      BASE_URL = "https://fantasysports.yahooapis.com/fantasy/v2"
+      CURRENT_USER_URL = "#{BASE_URL}/users;use_login=1"
+
+      def initialize(resource, keys: [], game_codes: [], subresources: [], **options)
+        @options = options
+        @url = options[:scope_to_user] ? CURRENT_USER_URL.dup : BASE_URL.dup
+        @resource = override_resource(resource.to_s)
+        @keys = Array(keys).map(&:to_s)
+        @game_codes = Array(game_codes).map(&:to_s)
+        @subresources = Array(subresources)
+      end
+
+      def build
+        validate_args!
+        singular_resource? ? build_resource_url : build_collection_url
+        return @url if @subresources.empty?
+
+        params = SubresourceParamBuilder.new(@subresources, **@options).build
+        @url.concat(params)
+      end
+
+      private
+
+      def override_resource(resource)
+        return "team" if resource == "pickem_team"
+        return "teams" if resource == "pickem_teams"
+
+        resource
+      end
+
+      def build_resource_url
+        @url.concat("/", @resource, "/", @keys.first)
+      end
+
+      def build_collection_url
+        @url.concat("/", @resource, collection_params)
+      end
+
+      def collection_params
+        if @resource == "games" && !@game_codes.empty?
+          return ";game_codes=#{@game_codes.join(",")}"
+        end
+
+        return "" if @keys.compact.empty?
+
+        ";#{singularize(@resource)}_keys=#{@keys.join(",")}"
+      end
+
+      def singular_resource?
+        singularize(@resource) == @resource
+      end
+
+      def singularize(resource)
+        Transformations::T.singularize(resource)
+      end
+
+      def validate_args!
+        if !@game_codes.empty? && !@keys.empty?
+          raise self.class::Error.new("Cannot build URL with both keys and game_codes")
+        end
+
+        if !@game_codes.empty? && @resource != "games"
+          raise self.class::Error.new("`game_codes` can only be used with Games collection")
+        end
+      end
+
+      class Error < StandardError
+      end
+    end
+  end
+end

data/lib/y_fantasy/cli.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module YFantasy
+  class CLI < Thor
+    include Thor::Actions
+
+    desc "version", "Prints the YFantasy gem version"
+    def version
+      require "y_fantasy/version"
+      puts YFantasy::VERSION
+    end
+
+    desc "nfl_teams", "Prints Yahoo NFL team information"
+    def nfl_teams
+      require "y_fantasy/ref/nfl"
+
+      YFantasy::Ref::Nfl::TEAM_KEY_MAP.each_with_index do |(key, team), idx|
+        if idx.zero?
+          puts format("%-15s %-15s %-10s %-10s", "City", "Team Name", "Abbrev", "Yahoo Key")
+          puts "-" * 55
+        end
+        puts format("%-15s %-15s %-10s %-10s", team[:city], team[:team_name], team[:abbrev], key)
+      end
+    end
+
+    desc "help", "Prints this help message"
+    def help
+      puts self.class.help
+    end
+
+    no_commands do
+      def self.help
+        <<~HELP
+          Usage: y_fantasy [command] [options]
+
+          Commands:
+            version   - Prints the YFantasy gem version
+            nfl_teams - Prints Yahoo NFL team information
+            help      - Prints this help message
+        HELP
+      end
+    end
+  end
+end

data/lib/y_fantasy/concerns/subresourceable.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module YFantasy
+  module Subresourceable
+    def self.included(base)
+      base.include(InstanceMethods)
+      base.extend(ClassMethods)
+    end
+
+    module InstanceMethods
+      def fetched_subresources
+        @fetched_subresources ||= Set.new
+      end
+
+      def add_fetched_subresources(subresources = [])
+        # Using wrap_in_array here because Array() will convert a hash to array
+        Transformations::T.wrap_in_array(subresources).each do |subresource|
+          case subresource
+          when Symbol
+            fetched_subresources << subresource
+          when Hash
+            key = subresource.keys.first
+            fetched_subresources << key
+            sub_instances = Transformations::T.wrap_in_array(send(key))
+            sub_instances&.each do |sub_instance|
+              sub_instance.add_fetched_subresources(subresource[key])
+            end
+          end
+        end
+      end
+    end
+
+    module ClassMethods
+      # TODO: may not need these first 3 methods if the subresource_tree works the way I want it to
+      def primary_subresources
+        @primary_subresources ||= []
+      end
+
+      def dependent_subresources
+        @dependent_subresources ||= []
+      end
+
+      def subresources
+        primary_subresources | dependent_subresources
+      end
+
+      def has_subresource(sub, klass:)
+        check_inheritance # This smells
+        klass.dependent? ? (dependent_subresources << sub) : (primary_subresources << sub)
+        add_to_subresource_tree(sub, klass)
+
+        define_method(sub) do
+          ivar = :"@#{sub}"
+          value = instance_variable_get(ivar)
+          return value if (value && value != []) || fetched_subresources.include?(sub)
+
+          value = instance_variable_set(ivar, self.class.fetch_subresource(key, sub))
+          add_fetched_subresources(sub)
+          value
+        end
+      end
+
+      def fetch_subresource(key, subresource)
+        resource = find(key, with: [subresource])
+        resource.send(subresource)
+      end
+
+      def add_to_subresource_tree(subresource, klass)
+        @subresource_tree ||= {}
+        @subresource_tree[subresource] = klass.subresources
+      end
+
+      def subresource_tree
+        @subresource_tree || {}
+      end
+
+      def check_inheritance
+        return if superclass == YFantasy::BaseResource || superclass == YFantasy::BaseSubresource
+
+        raise YFantasy::Subresourceable::Error.new("#{self} does not inherit from BaseResource")
+      end
+    end
+
+    class Error < StandardError
+    end
+  end
+end

data/lib/y_fantasy/ref/nfl.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module YFantasy
+  module Ref
+    module Nfl
+      TEAM_KEY_MAP = {
+        "nfl.t.1": {key: "nfl.t.1", abbrev: "atl", city: "Atlanta", team_name: "Falcons"},
+        "nfl.t.2": {key: "nfl.t.2", abbrev: "buf", city: "Buffalo", team_name: "Bills"},
+        "nfl.t.3": {key: "nfl.t.3", abbrev: "chi", city: "Chicago", team_name: "Bears"},
+        "nfl.t.4": {key: "nfl.t.4", abbrev: "cin", city: "Cincinnati", team_name: "Bengals"},
+        "nfl.t.5": {key: "nfl.t.5", abbrev: "cle", city: "Cleveland", team_name: "Browns"},
+        "nfl.t.6": {key: "nfl.t.6", abbrev: "dal", city: "Dallas", team_name: "Cowboys"},
+        "nfl.t.7": {key: "nfl.t.7", abbrev: "den", city: "Denver", team_name: "Broncos"},
+        "nfl.t.8": {key: "nfl.t.8", abbrev: "det", city: "Detroit", team_name: "Lions"},
+        "nfl.t.9": {key: "nfl.t.9", abbrev: "gb", city: "Green Bay", team_name: "Packers"},
+        "nfl.t.10": {key: "nfl.t.10", abbrev: "ten", city: "Tennessee", team_name: "Titans"},
+        "nfl.t.11": {key: "nfl.t.11", abbrev: "ind", city: "Indianapolis", team_name: "Colts"},
+        "nfl.t.12": {key: "nfl.t.12", abbrev: "kc", city: "Kansas City", team_name: "Chiefs"},
+        "nfl.t.13": {key: "nfl.t.13", abbrev: "lv", city: "Las Vegas", team_name: "Rakeyers"},
+        "nfl.t.14": {key: "nfl.t.14", abbrev: "lar", city: "Los Angeles", team_name: "Rams"},
+        "nfl.t.15": {key: "nfl.t.15", abbrev: "mia", city: "Miami", team_name: "Dolphins"},
+        "nfl.t.16": {key: "nfl.t.16", abbrev: "min", city: "Minnesota", team_name: "Vikings"},
+        "nfl.t.17": {key: "nfl.t.17", abbrev: "ne", city: "New England", team_name: "Patriots"},
+        "nfl.t.18": {key: "nfl.t.18", abbrev: "no", city: "New Orleans", team_name: "Saints"},
+        "nfl.t.19": {key: "nfl.t.19", abbrev: "nyg", city: "New York", team_name: "Giants"},
+        "nfl.t.20": {key: "nfl.t.20", abbrev: "nyj", city: "New York", team_name: "Jets"},
+        "nfl.t.21": {key: "nfl.t.21", abbrev: "phi", city: "Philadelphia", team_name: "Eagles"},
+        "nfl.t.22": {key: "nfl.t.22", abbrev: "ari", city: "Arizona", team_name: "Cardinals"},
+        "nfl.t.23": {key: "nfl.t.23", abbrev: "pit", city: "Pittsburgh", team_name: "Steelers"},
+        "nfl.t.24": {key: "nfl.t.24", abbrev: "lac", city: "Los Angeles", team_name: "Chargers"},
+        "nfl.t.25": {key: "nfl.t.25", abbrev: "sf", city: "San Francisco", team_name: "49ers"},
+        "nfl.t.26": {key: "nfl.t.26", abbrev: "sea", city: "Seattle", team_name: "Seahawks"},
+        "nfl.t.27": {key: "nfl.t.27", abbrev: "tb", city: "Tampa Bay", team_name: "Buccaneers"},
+        "nfl.t.28": {key: "nfl.t.28", abbrev: "was", city: "Washington", team_name: "Commanders"},
+        "nfl.t.29": {key: "nfl.t.29", abbrev: "car", city: "Carolina", team_name: "Panthers"},
+        "nfl.t.30": {key: "nfl.t.30", abbrev: "jax", city: "Jacksonville", team_name: "Jaguars"},
+        "nfl.t.33": {key: "nfl.t.33", abbrev: "bal", city: "Baltimore", team_name: "Ravens"},
+        "nfl.t.34": {key: "nfl.t.34", abbrev: "hou", city: "Houston", team_name: "Texans"}
+      }
+
+      def team(key)
+        TEAM_KEY_MAP.fetch(key.to_sym, nil)
+      end
+      module_function :team
+
+      # TODO: Work in progress...
+      STAT_MAP = {
+        0 => "Games Played",
+        8 => "Rush Att",
+        9 => "Rush Yds",
+        11 => "Rec",
+        12 => "Rec Yds",
+        13 => "Rec TD"
+      }
+    end
+  end
+end

data/lib/y_fantasy/resources/base_resource.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module YFantasy
+  # @abstract Base class for all "primary" Yahoo Fantasy Sports API resources.
+  # @note Primary resources are those with a Yahoo Key/ID, that can be referenced in a Yahoo Fantasy API URL.
+  #  This includes Game, League, Team, Player, Group, and PickemTeam.
+  class BaseResource
+    extend Forwardable
+    extend Dry::Initializer[undefined: false]
+    include Subresourceable
+
+    # Error class for BaseResource exceptions
+    class Error < StandardError
+    end
+
+    # CLASS METHODS
+    class << self
+      # Finds all resources of the current type
+      # @param keys [Array<String, Symbol, Integer>] Keys to find resources by
+      # @param with [Array<Symbol>, Symbol] Subresources to include with the response
+      # @param scope_to_user [Boolean] Whether to scope the request to the authenticated user
+      # @return [Array<BaseResource>] Collection of resources
+      def find_all(keys = [], with: [], scope_to_user: false)
+        keys = Array(keys)
+        subresources = Transformations::T.wrap_in_array(with)
+        data = YFantasy::Api::Client.get(
+          collection_name, keys: keys, subresources: subresources, scope_to_user: scope_to_user
+        )
+        resources = Transformations::CollectionTransformer.new(collection_name).call(data)
+        resources.each { |resource| resource.add_fetched_subresources(subresources) }
+        resources
+      end
+
+      # Finds a single resource by key
+      # @param key [String, Symbol, Integer] The key to find the resource by
+      # @param with [Array<Symbol>, Symbol] Subresources to include with the response
+      # @param options [Hash] Additional options for the request
+      # @return [BaseResource] The requested resource
+      # @raise [Error] If invalid options are provided
+      def find(key, with: [], **options)
+        validate_options(options)
+        subresources = Transformations::T.wrap_in_array(with)
+        SubresourceValidator.validate!(self, subresources)
+        # TODO: Remove
+        # puts "\n YFantasy::Api::Client.get('#{resource_name}', '#{key}', #{subresources}, #{options}) \n"
+
+        data = YFantasy::Api::Client.get(resource_name, keys: key, subresources: subresources, **options)
+        resource = Transformations.transformer_for(resource_name).call(data)
+        resource.add_fetched_subresources(subresources)
+        resource
+      end
+
+      # Always returns false for primary resources (anything that inherits from BaseResource)
+      # @return [Boolean] False by default.
+      def dependent?
+        false
+      end
+
+      # Returns the resource name as a symbol
+      # @return [Symbol, nil] The resource name or nil if this is the BaseResource
+      def resource_name
+        return if base_resource?
+
+        to_s.split("::").last.scan(/[A-Z][a-z]+/).join("_").downcase.to_sym
+      end
+
+      # Returns the collection name (aka pluralized resource name)
+      # @return [Symbol, nil] The collection name or nil if this is the BaseResource
+      def collection_name
+        return if base_resource?
+
+        :"#{resource_name}s"
+      end
+
+      private
+
+      # Determines if this is the base resource class
+      # @return [Boolean] True if this is the BaseResource class
+      def base_resource?
+        self == YFantasy::BaseResource
+      end
+
+      # Creates a transformer that instantiates a single object of the given class
+      # @param klass [Class] The class to instantiate
+      # @return [Transformations::Instantiator] A transformer that instantiates the class
+      def instance_of(klass)
+        Transformations::Instantiator.new(klass)
+      end
+
+      # Creates a transformer that instantiates an array of objects of the given class
+      # @param klass [Class] The class to instantiate
+      # @return [Transformations::Instantiator] A transformer that instantiates an array of the class
+      def array_of(klass)
+        Transformations::Instantiator.new(klass, collection: true)
+      end
+
+      # Validates options hash for API requests
+      # @param options [Hash] Options hash to validate
+      # @raise [Error] If invalid options are provided
+      def validate_options(options)
+        return unless options[:scope_to_user]
+
+        raise Error.new("`scope_to_user` is not valid when requesting a single resource. Use `.find_all`.")
+      end
+    end
+
+    # INSTANCE METHODS
+
+    # Returns the key of the resource
+    # @return [Object, nil] The resource key or nil if not applicable
+    def key
+      if (name = self.class.resource_name)
+        public_send(:"#{name}_key")
+      end
+    end
+  end
+end

data/lib/y_fantasy/resources/base_subresource.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module YFantasy
+  class BaseSubresource
+    extend Dry::Initializer[undefined: false]
+    include Subresourceable
+
+    class << self
+      def dependent?
+        true
+      end
+
+      def resource_name
+        return if self == YFantasy::BaseSubresource
+
+        to_s.split("::").last.scan(/[A-Z][a-z]+/).join("_").downcase.to_sym
+      end
+
+      def find(resource_name, key)
+        data = YFantasy::Api::Client.get(resource_name, keys: key)
+        Transformations.transformer_for(resource_name).call(data)
+      end
+
+      private
+
+      def array_of(klass)
+        Transformations::Instantiator.new(klass, collection: true)
+      end
+    end
+  end
+end

data/lib/y_fantasy/resources/game/game_week.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module YFantasy
+  class Game
+    # Represents a week in a fantasy game schedule
+    class GameWeek < BaseSubresource
+      # --- REQUIRED ATTRIBUTES ----------------------------------------------------------------------------------------
+
+      # @!attribute [r] week
+      # @return [Integer] the week number
+      option :week, type: Types::Coercible::Integer
+
+      # @!attribute [r] display_name
+      # @return [String] the week number as a string
+      option :display_name
+
+      # @!attribute [r] start
+      # @return [Date] week start date
+      option :start, type: Types::Params::Date
+
+      # @!attribute [r] end
+      # @return [Date] week end date
+      option :end, type: Types::Params::Date
+    end
+  end
+end

data/lib/y_fantasy/resources/game/position_type.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module YFantasy
+  class Game
+    # Represents a position type within a fantasy game
+    class PositionType < BaseSubresource
+      # --- REQUIRED ATTRIBUTES ----------------------------------------------------------------------------------------
+
+      # @!attribute [r] type
+      # @return [String] position type abbreviation
+      # @example "O", "K", "DT"
+      option :type
+
+      # @!attribute [r] display_name
+      # @return [String] full name of the position type
+      # @example "Offense", "Kickers", "Defense/Special Teams"
+      option :display_name
+    end
+  end
+end