sleeper_rb 0.2.0

data/lib/sleeper_rb/resources/traded_pick.rb

@@ -0,0 +1,63 @@
+# frozen-string-literal: true
+
+module SleeperRb
+  module Resources
+    ##
+    # Represents a traded draft pick for any season of the League.
+    class TradedPick
+      include SleeperRb::Utilities::Cache
+
+      ##
+      # :attr_reader: league
+
+      ##
+      # :attr_reader: season
+
+      ##
+      # :attr_reader: round
+
+      ##
+      # :attr_reader: previous_owner_id
+
+      ##
+      # :attr_reader: roster_id
+
+      ##
+      # :attr_reader: owner_id
+
+      ##
+      # :attr_reader: draft
+
+      cached_attr :league, :draft, :season, :round, :roster_id, :previous_owner_id, :owner_id
+
+      skip_refresh :all
+
+      ##
+      # :method: original_roster
+      # The roster which originally owned this pick.
+      #
+      # @return [{SleeperRb::Resources::League::Roster}[SleeperRb::Resources::league::Roster]]
+      cached_association :original_roster do
+        league.rosters.detect { |roster| roster.roster_id == roster_id }
+      end
+
+      ##
+      # :method: previous_roster
+      # The last roster to have owned this pick before the current one (can be same as original_roster).
+      #
+      # @return [{SleeperRb::Resources::League::Roster}[SleeperRb::Resources::league::Roster]]
+      cached_association :previous_roster do
+        league.rosters.detect { |roster| roster.roster_id == previous_owner_id }
+      end
+
+      ##
+      # :method: current_roster
+      # The roster which currently owns this pick.
+      #
+      # @return [{SleeperRb::Resources::League::Roster}[SleeperRb::Resources::league::Roster]]
+      cached_association :current_roster do
+        league.rosters.detect { |roster| roster.roster_id == owner_id }
+      end
+    end
+  end
+end

data/lib/sleeper_rb/resources/traded_pick_array.rb

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

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

@@ -0,0 +1,20 @@
+# frozen-string-literal: true
+
+module SleeperRb
+  module Resources
+    class User
+      ##
+      # Metadata exists only when the User object was retrieved from a league. Includes team_name for that league.
+      class Metadata
+        include SleeperRb::Utilities::Cache
+
+        ##
+        # :attr_reader: team_name
+
+        cached_attr :team_name
+
+        skip_refresh :all
+      end
+    end
+  end
+end

data/lib/sleeper_rb/resources/user.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require_relative "user/metadata"
+
+module SleeperRb
+  module Resources
+    ##
+    # The User resource represents a single user in Sleeper. This also serves as the access points for associated data.
+    class User
+      include SleeperRb::Utilities::Request
+      include SleeperRb::Utilities::Cache
+
+      ##
+      # :attr_reader: user_id
+
+      ##
+      # :attr_reader: username
+
+      ##
+      # :attr_reader: display_name
+
+      ##
+      # :attr_reader: is_owner
+
+      ##
+      # :method: metadata
+      #
+      # @return [{SleeperRb::Resources::User::Metadata}[rdoc-ref:SleeperRb::Resources::User::Metadata]]
+
+      ##
+      # :method: metadata
+      #
+      # @return [{SleeperRb::Resources::User::Metadata}[rdoc-ref:SleeperRb::Resources::User::Metadata]]
+
+      ##
+      # :method: avatar
+      #
+      # @return [{SleeperRb::Resources::Avatar}[rdoc-ref:SleeperRb::Resources::Avatar]]
+
+      cached_attr :user_id, :username, :display_name, :is_owner,
+                  metadata: ->(hash) { Metadata.new(hash) },
+                  avatar: ->(id) { id ? Resources::Avatar.new(avatar_id: id) : nil }
+
+      delegate(*Metadata.cached_attrs.keys, to: :metadata)
+
+      ##
+      # :method: leagues
+      # Retrieves leagues for the user for the given season.
+      # :call-seq:
+      #   leagues(season_year)
+      #
+      # @param season_year [String] The year in which the leagues were played
+      #
+      # @return [{SleeperRb::Resources::LeagueArray}[rdoc-ref:SleeperRb::Resources::LeagueArray]]
+      cached_association :leagues do |season_year|
+        retrieve_leagues!(season_year)
+      end
+
+      ##
+      # :method: drafts
+      # Retrieves all drafts for the user for the given season
+      # :call-seq:
+      #   drafts(season_year)
+      #
+      # @param season_year [String] The year in which the leagues were played
+      #
+      # @return [{SleeperRb::Resources::DraftArray}[rdoc-ref:SleeperRb::Resources::DraftArray]]
+      cached_association :drafts do |season_year|
+        retrieve_drafts!(season_year)
+      end
+
+      ##
+      # Initializes a user, with either username or user_id.
+      #
+      # @param username [String] The current username
+      #
+      # @param user_id [String] The numerical user_id
+      def initialize(opts)
+        raise ArgumentError, "must provide either user_id or username" unless opts[:user_id] || opts[:username]
+
+        super
+      end
+
+      private
+
+      def retrieve_values!
+        uri = URI("#{BASE_URL}/user/#{@user_id || @username}")
+        execute_request(uri)
+      end
+
+      def retrieve_leagues!(season_year)
+        uri = URI("#{BASE_URL}/user/#{user_id}/leagues/nfl/#{season_year}")
+        response = execute_request(uri)
+        LeagueArray.new(response.map { |hash| Resources::League.new(hash) })
+      end
+
+      def retrieve_drafts!(season_year)
+        uri = URI("#{BASE_URL}/user/#{user_id}/drafts/nfl/#{season_year}")
+        response = execute_request(uri)
+        DraftArray.new(response.map { |hash| Resources::Draft.new(hash) })
+      end
+    end
+  end
+end

data/lib/sleeper_rb/resources/user_array.rb

@@ -0,0 +1,9 @@
+# frozen-string-literal: true
+
+module SleeperRb
+  module Resources
+    ##
+    # Implements {SleeperRb::Utilities::ArrayProxy}[rdoc-ref:SleeperRb::Utilities::ArrayProxy] and wraps User objects.
+    class UserArray < SleeperRb::Utilities::ArrayProxy; end
+  end
+end

data/lib/sleeper_rb/utilities/array_proxy.rb

@@ -0,0 +1,47 @@
+# frozen-string-literal: true
+
+require "delegate"
+
+module SleeperRb
+  module Utilities
+    ##
+    # A wrapper for arrays of various SleeperRb::Resources that implements a light ActiveRecord-inspired syntax
+    # for filtering the underlying collection.
+    #
+    # Valid operators for use in #where are: gt, gte, lt, lte, not.
+    class ArrayProxy < SimpleDelegator
+      VALID_OPERATORS = {
+        gt: ->(element, comparison) { element > comparison },
+        gte: ->(element, comparison) { element >= comparison },
+        lt: ->(element, comparison) { element < comparison },
+        lte: ->(element, comparison) { element <= comparison },
+        not: ->(element, comparison) { element != comparison },
+        eq: ->(element, comparison) { element == comparison },
+        in: ->(element, comparison) { comparison.include?(element) }
+      }.freeze
+
+      def where(options = {})
+        filtered = __getobj__.dup
+        options.each do |field, value|
+          value = { eq: value } unless value.is_a?(Hash)
+          raise ArgumentError, "Invalid operator, must be one of: #{valid_operators}" unless valid_keys?(value)
+
+          value.each do |operator, comparison|
+            filtered = filtered.select { |object| VALID_OPERATORS[operator].call(object.send(field), comparison) }
+          end
+        end
+        self.class.new(filtered)
+      end
+
+      private
+
+      def valid_operators
+        VALID_OPERATORS.keys.join(", ")
+      end
+
+      def valid_keys?(hash)
+        hash.keys.all? { |key| VALID_OPERATORS.keys.include?(key) }
+      end
+    end
+  end
+end

data/lib/sleeper_rb/utilities/cache.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module SleeperRb
+  module Utilities
+    ##
+    # This module encapsulates the logic for caching and refreshing values retrieved from the Sleeper API.
+    module Cache
+      ##
+      # Methods to be extended into the class when included.
+      module ClassMethods
+        DEFAULT_TRANSLATORS = {
+          int_to_bool: ->(int) { int == 1 },
+          float: ->(float) { float.to_f.round(2) },
+          timestamp: ->(epoch_string) { Time.at(epoch_string.to_i / 1000).utc }
+        }.freeze
+        ##
+        # Creates a memoized attribute reader for the named attributes.
+        #
+        # = Example
+        # +cached_attr :display_name, :username, foo: ->(x) { x + 3 }+
+        def cached_attr(*attrs)
+          attrs.each do |attr|
+            if attr.is_a?(Hash)
+              attr.each do |field_name, translator|
+                translator = DEFAULT_TRANSLATORS[translator] if translator.is_a?(Symbol)
+                create_method(field_name, translator)
+              end
+            else
+              create_method(attr, ->(x) { x })
+            end
+          end
+        end
+
+        ##
+        # Creates a memoized association that returns another resource.
+        def cached_association(name, &block)
+          define_method(name) do |arg = nil|
+            if arg
+              cached_associations[name] ||= {}
+              cached_associations[name][arg.to_s] ||= instance_exec(arg, &block)
+            else
+              cached_associations[name] ||= instance_exec(&block)
+            end
+          end
+        end
+
+        ##
+        # Takes in a list of fields which should be excluded from refresh. Use :all for models which do not have
+        # any endpoint but only retrieve their data from another object. These models have no API source to refresh
+        # themselves, but they still have associations.
+        def skip_refresh(*fields)
+          fields.any? { |field| field == :all } ? @skip_refresh_fields = :all : skip_refresh_fields.concat(fields)
+        end
+
+        ##
+        # The stored mapping of cached attribute names to their translator functions.
+        def cached_attrs
+          @cached_attrs ||= {}
+        end
+
+        ##
+        # The stored list of fields which should be excluded from refresh.
+        def skip_refresh_fields
+          @skip_refresh_fields ||= []
+        end
+
+        private
+
+        def create_method(field_name, translator)
+          cached_attrs[field_name.to_sym] = translator
+          skip_refresh_fields << field_name.to_sym if field_name.to_s =~ /\w+_id/
+          define_method(field_name) do
+            ivar = :"@#{field_name}"
+            instance_variable_get(ivar) || instance_variable_set(ivar, translator.call(values[field_name.to_sym]))
+          end
+        end
+      end
+
+      ##
+      # Ensures that ClassMethods are extended into the base class when including.
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      ##
+      # Sets up an object with values for any cached_attrs pre-initialized if provided.
+      #
+      # @param opts [Hash] Key/value pairs that can match any cached_attr.
+      def initialize(opts = {})
+        opts.slice(*cached_attrs.keys).each do |key, val|
+          instance_variable_set(:"@#{key}", cached_attrs[key].call(val))
+        end
+      end
+
+      ##
+      # Refreshes all associations and memoized values set by cached_attr.
+      #
+      # @return [self]
+      def refresh
+        cached_attrs.keys.reject { |k| skip_refresh_fields == :all || skip_refresh_fields.include?(k) }.each do |attr|
+          ivar = :"@#{attr}"
+          instance_variable_set(ivar, nil)
+        end
+        @values = nil
+        @cached_associations = {}
+        self
+      end
+
+      private
+
+      def cached_attrs
+        self.class.cached_attrs
+      end
+
+      def skip_refresh_fields
+        self.class.skip_refresh_fields
+      end
+
+      def cached_associations
+        @cached_associations ||= {}
+      end
+
+      def values
+        @values ||= retrieve_values!
+      end
+
+      def retrieve_values!
+        {}
+      end
+    end
+  end
+end

data/lib/sleeper_rb/utilities/request.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "tempfile"
+
+module SleeperRb
+  module Utilities
+    ##
+    # This module encapsulates the logic for handling the response when querying from the Sleeper API.
+    module Request
+      BASE_URL = "https://api.sleeper.app/v1"
+      CDN_BASE_URL = "https://sleepercdn.com"
+
+      private
+
+      def execute_request(url)
+        response = Net::HTTP.get_response(URI(url))
+
+        case response.code.to_i
+        when 200 then JSON.parse(response.body, symbolize_names: true)
+        when 400 then raise BadRequest
+        when 404 then raise NotFound
+        when 429 then raise RateLimitExceeded
+        else raise ServerError
+        end
+      end
+
+      def download_file(url, filename)
+        uri = URI(url)
+        Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+          resp = http.get(uri.path)
+          file = Tempfile.new(filename)
+          file.binmode
+          file.write(resp.body)
+          file.flush
+          file
+        end
+      end
+    end
+  end
+end

data/lib/sleeper_rb/utilities/roster_position.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module SleeperRb
+  module Utilities
+    ##
+    # A string representing a roster position. See VALID_ROSTER_POSITIONS.
+    # For every possible position in VALID_ROSTER_POSITIONS, there is a corresponding predicate method (e.g. `qb?`).
+    class RosterPosition
+      attr_reader :position
+
+      def initialize(position)
+        @position = position.upcase
+      end
+
+      VALID_ROSTER_POSITIONS = %w[
+        qb rb wr te k dst flex bn ir super_flex ol dl de lb olb mlb fs ss db cb nb c rg lg lt rt ot g
+      ].freeze
+
+      VALID_ROSTER_POSITIONS.each do |position_key|
+        define_method("#{position_key}?") { position == position_key.upcase }
+      end
+
+      def ==(other)
+        return position == other.position.upcase if other.respond_to?(:position)
+
+        position == other.upcase
+      end
+    end
+  end
+end

data/lib/sleeper_rb/version.rb

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

data/lib/sleeper_rb.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/delegation"
+require_relative "sleeper_rb/version"
+require_relative "sleeper_rb/client"
+
+module SleeperRb
+  class BadRequest < StandardError; end
+
+  class NotFound < StandardError; end
+
+  class ServerError < StandardError; end
+
+  class RateLimitExceeded < StandardError; end
+end

data/sleeper_rb.gemspec

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "lib/sleeper_rb/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "sleeper_rb"
+  spec.version       = SleeperRb::VERSION
+  spec.authors       = ["Stephen Weil"]
+  spec.email         = ["stephen.weil@gmail.com"]
+
+  spec.summary       = "A wrapper for interacting with the Sleeper Fantasy Football API."
+  spec.description   = "Provides an object-oriented interface for the Sleeper Fantasy Football API."
+  spec.homepage      = "https://github.com/sjweil9/sleeper_rb"
+  spec.license       = "MIT"
+  spec.required_ruby_version = ">= 2.5.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/sjweil9/sleeper_rb"
+  spec.metadata["changelog_uri"] = "https://github.com/sjweil9/sleeper_rb/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+
+  # For more information and examples about making a new gem, checkout our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end