sleeper_api 1.0.0

data/lib/sleeper_api/league.rb

@@ -0,0 +1,399 @@
+# frozen_string_literal: true
+
+module SleeperApi
+  class League
+    include Helpers
+
+    # League attributes from the API.
+    ATTRIBUTES = %w[name league_id total_rosters status sport settings season_type season scoring_settings
+                    roster_positions previous_league_id draft_id bracket_id bracket_overrides_id loser_bracket_id
+                    loser_bracket_overrides_id group_id avatar company_id shard last_message_id last_author_avatar
+                    last_author_display_name last_author_id last_author_is_bot last_message_attachment
+                    last_message_text_map last_message_time last_pinned_message_id last_read_id metadata].freeze
+
+    attr_reader :league_id, :weeks
+
+    # @param league_id [String] League identifier
+    # @param client [SleeperApi::Client] HTTP client instance
+    # @param no_data [Boolean] Skip initial data fetch (default: false)
+    # @raise [ArgumentError] If league_id is empty
+    def initialize(league_id, client, no_data: false)
+      raise ArgumentError, "league_id must be a non-empty string" if league_id.to_s.empty?
+
+      @league_id = league_id
+      @client = client
+      @weeks = 1..17
+      @league_data = nil
+      @league_rosters = nil
+      @league_users = nil
+      @matchups = nil
+      @transactions = nil
+      @playoff_bracket = nil
+      @toilet_bowl = nil
+
+      fetch_league_data unless no_data
+    end
+
+    # Dynamically define attribute readers for league data.
+    ATTRIBUTES.each do |attr|
+      define_method(attr) do
+        @league_data[attr]
+      end
+    end
+
+    # Generate avatar URL from ID.
+    #
+    # @return [String, nil] Full avatar URL or nil if no avatar
+    def avatar_url
+      avatar ? "https://sleepercdn.com/avatars/#{avatar}" : nil
+    end
+
+    # Get the reigning champion's roster.
+    #
+    # @return [Hash, nil] Formatted roster data or nil if no champion data
+    def reigning_champ
+      roster_id = @league_data&.dig("metadata", "latest_league_winner_roster_id")
+      return nil unless roster_id
+
+      roster_id = roster_id.to_i
+      rosters(roster_id: roster_id)
+    end
+
+    # Get all league users (raw data).
+    #
+    # @return [Array<Hash>] Raw user data from API
+    def league_rosters
+      fetch_rosters unless @league_rosters
+      @league_rosters
+    end
+
+    # Get all matchups across all weeks.
+    #
+    # @return [Hash{Integer => Array<Hash>}] Week number to matchup data
+    def league_users
+      fetch_users unless @league_users
+      @league_users
+    end
+
+    # Get all matchups across all weeks.
+    #
+    # @return [Hash{Integer => Array<Hash>}] Week number to matchup data
+    def matchups
+      fetch_matchups unless @matchups&.keys&.sort == @weeks.to_a.sort
+      @matchups
+    end
+
+    # Get formatted rosters with team names, records, and player lists.
+    #
+    # @param roster_id [Integer, nil] Filter by specific roster
+    # @param user_id [String, nil] Filter by user owner
+    # @return [Array<Hash>] Formatted roster objects
+    #
+    # @example Get all rosters
+    #   rosters = league.rosters
+    #   roster = rosters.first
+    #   puts "#{roster[:owner_display_name]}: #{roster[:wins]}-#{roster[:losses]}"
+    #
+    # @example Get my roster
+    #   my_roster = league.rosters(user_id: my_user_id)
+    def rosters(roster_id: nil, user_id: nil)
+      fetch_rosters unless @league_rosters
+      fetch_users unless @league_users
+
+      format_rosters(roster_id: roster_id, user_id: user_id)
+    end
+
+    # Get formatted matchups for a specific week.
+    #
+    # @param week [Integer] Week number (1-17)
+    # @return [Array<Hash>] Matchup data with scoring breakdown
+    # @raise [ArgumentError] If week is invalid
+    #
+    # @example
+    #   matchups = league.matchups_by_week(week: 5)
+    #   matchups.each do |matchup|
+    #     matchup[:rosters].each do |team|
+    #       puts "#{team[:points]} points from #{team[:starters].length} starters"
+    #     end
+    #   end
+    def matchups_by_week(week: nil)
+      raise ArgumentError, "Week must be between 1 and 17" unless @weeks.include?(week)
+
+      fetch_matchups([week]) unless @matchups&.key?(week)
+      format_matchups(week)
+    end
+
+    # Get formatted league users with team names and commissioner status.
+    #
+    # @return [Array<Hash>] Formatted user objects
+    #
+    # @example
+    #   users = league.users
+    #   users.each do |user|
+    #     role = user[:commissioner] ? "(Commissioner)" : ""
+    #     puts "#{user[:display_name]} #{role}"
+    #   end
+    def users
+      fetch_users unless @fetch_users
+      format_users
+    end
+
+    # Get formatted transactions for a specific week.
+    #
+    # @param week [Integer] Week number (1-17)
+    # @return [Array<Hash>] Transaction data with adds/drops and draft picks
+    # @raise [ArgumentError] If week is invalid
+    #
+    # @example
+    #   transactions = league.transactions(week: 5)
+    #   transactions.each do |tx|
+    #     puts "#{tx[:type]}: #{tx[:adds]&.length || 0} adds, #{tx[:drops]&.length || 0} drops"
+    #   end
+    def transactions(week: nil)
+      raise ArgumentError, "Week must be between 1 and 17" unless @weeks.include?(week)
+
+      fetch_transactions([week]) unless @transactions&.key?(week)
+      format_transactions(week)
+    end
+
+    # Get formatted playoff bracket with team names.
+    #
+    # @return [Array<Hash>] Bracket matchups with winner/loser team names
+    def playoff_bracket
+      fetch_playoff_bracket unless @playoff_bracket
+      @playoff_bracket
+    end
+
+    # Get formatted toilet bowl (losers bracket) with team names.
+    #
+    # @return [Array<Hash>] Bracket matchups with winner/loser team names
+    def toilet_bowl
+      fetch_toilet_bowl unless @toilet_bowl
+      @toilet_bowl
+    end
+
+    private
+
+    def fetch_league_data
+      @league_data ||= @client.get_league(@league_id)
+    end
+
+    def fetch_rosters
+      @league_rosters ||= @client.get_league_rosters(@league_id)
+    end
+
+    def fetch_users
+      @league_users ||= @client.get_league_users(@league_id)
+    end
+
+    def fetch_matchups(weeks = @weeks)
+      @matchups ||= {}
+      weeks.each do |week|
+        next if @matchups[week]
+
+        @matchups[week] = @client.get_league_matchups(@league_id, week)
+      end
+    end
+
+    def fetch_transactions(weeks = @weeks)
+      @transactions ||= {}
+      weeks.each do |week|
+        next if @transactions[week]
+
+        @transactions[week] = @client.get_transactions(@league_id, week)
+      end
+    end
+
+    def fetch_playoff_bracket
+      return @playoff_bracket if @playoff_bracket
+
+      response = @client.get_playoff_bracket(@league_id)
+      @playoff_bracket = response.parsed_response.map do |matchup|
+        deep_symbolize_keys(matchup).merge(
+          team1_owner: users.find do |user|
+            user[:user_id] == rosters(roster_id: matchup["t1"])&.first&.dig(:owner_id)
+          end&.dig(:team_name),
+          team2_owner: users.find do |user|
+            user[:user_id] == rosters(roster_id: matchup["t2"])&.first&.dig(:owner_id)
+          end&.dig(:team_name),
+          winner_owner: if matchup["w"]
+                          users.find do |user|
+                            user[:user_id] == rosters(roster_id: matchup["w"])&.first&.dig(:owner_id)
+                          end&.dig(:team_name)
+                        end,
+          loser_owner: if matchup["l"]
+                         users.find do |user|
+                           user[:user_id] == rosters(roster_id: matchup["l"])&.first&.dig(:owner_id)
+                         end&.dig(:team_name)
+                       end
+        )
+      end
+      @playoff_bracket
+    end
+
+    def fetch_toilet_bowl
+      return @toilet_bowl if @toilet_bowl
+
+      response = @client.get_toilet_bowl(@league_id)
+      @toilet_bowl = response.parsed_response.map do |matchup|
+        deep_symbolize_keys(matchup).merge(
+          team1_owner: users.find do |u|
+            u[:user_id] == rosters(roster_id: matchup["t1"])&.first&.dig(:owner_id)
+          end&.dig(:team_name),
+          team2_owner: users.find do |u|
+            u[:user_id] == rosters(roster_id: matchup["t2"])&.first&.dig(:owner_id)
+          end&.dig(:team_name),
+          winner_owner: if matchup["w"]
+                          users.find do |u|
+                            u[:user_id] == rosters(roster_id: matchup["w"])&.first&.dig(:owner_id)
+                          end&.dig(:team_name)
+                        end,
+          loser_owner: if matchup["l"]
+                         users.find do |u|
+                           u[:user_id] == rosters(roster_id: matchup["l"])&.first&.dig(:owner_id)
+                         end&.dig(:team_name)
+                       end
+        )
+      end
+      @toilet_bowl
+    end
+
+    def format_rosters(roster_id: nil, user_id: nil)
+      rosters = @league_rosters
+
+      rosters = rosters.select { |roster| roster["roster_id"] == roster_id } if roster_id
+
+      rosters = rosters.select { |roster| roster["owner_id"] == user_id } if user_id
+
+      rosters.map do |roster|
+        user = @league_users.find { |user| user["user_id"] == roster["owner_id"] }
+        roster_metadata = roster["metadata"]
+        roster_settings = roster["settings"]
+
+        {
+          roster_id: roster["roster_id"],
+          league_id: roster["league_id"],
+          owner_id: roster["owner_id"],
+          owner_display_name: user&.dig("display_name") || "Unknown",
+          team_name: user&.dig("metadata", "team_name") || "Unknown",
+          team_icon: user&.dig("metadata", "avatar"),
+          starters: roster["starters"] || [],
+          injured_reserve: roster["reserve"] || [],
+          taxi: roster["taxi"] || [],
+          bench: (roster["players"] || []) - (roster["starters"] || []) - (roster["reserve"] || []) - (roster["taxi"] || []),
+          total_points: roster_settings&.dig("fpts"),
+          wins: roster_settings&.dig("wins"),
+          ties: roster_settings&.dig("ties"),
+          losses: roster_settings&.dig("losses"),
+          remaining_faab: (@league_data&.dig("settings",
+                                             "waiver_budget") || 0) - (roster_settings&.dig("waiver_budget_used") || 0),
+          faab_used: roster_settings&.dig("waiver_budget_used"),
+          waiver_position: roster_settings&.dig("waiver_position"),
+          streak: roster_metadata&.dig("streak"),
+          co_owners: roster["co_owner"],
+          keepers: roster["keepers"],
+          players_map: roster["player_map"],
+          players: roster["players"],
+          metadata: roster_metadata.is_a?(Hash) ? roster_metadata.transform_keys(&:to_sym) : roster_metadata,
+          settings: roster_settings.is_a?(Hash) ? roster_settings.transform_keys(&:to_sym) : roster_settings
+        }
+      end
+    end
+
+    def format_matchups(week)
+      week_matchups = @matchups[week] || []
+      return [] if week_matchups.empty?
+
+      week_matchups.group_by { |match| match["matchup_id"] }.map do |matchup_id, matchup_entries|
+        next unless matchup_id
+
+        {
+          matchup_id: matchup_id,
+          rosters: matchup_entries.map do |roster|
+            starters = roster["starters"]
+
+            bench = roster["players"] - starters
+            {
+              roster_id: roster["roster_id"],
+              points: roster["points"],
+              custom_points: roster["custom_points"],
+              total_points: roster["points"] + (roster["custom_points"] || 0),
+              starters: starters,
+              bench: bench,
+              starter_points: (starters || []).map do |starter_id|
+                { starter_id => roster["players_points"]&.dig(starter_id) || 0 }
+              end,
+              bench_points: bench.map do |bench_player_id|
+                { bench_player_id => roster["players_points"]&.dig(bench_player_id) || 0 }
+              end
+            }
+          end
+        }
+      end
+    end
+
+    def format_users
+      (@league_users || []).map do |user|
+        user_settings = user["settings"]
+        user_metadata = user["metadata"]
+
+        {
+          user_id: user["user_id"],
+          username: user["username"],
+          display_name: user["display_name"],
+          avatar_id: user["avatar"],
+          team_name: user_metadata["team_name"],
+          commissioner: user["is_owner"],
+          is_bot: user["is_bot"],
+          metadata: user_metadata.is_a?(Hash) ? user_metadata.transform_keys(&:to_sym) : user_metadata,
+          settings: user_settings.is_a?(Hash) ? user_settings.transform_keys(&:to_sym) : user_settings
+        }
+      end
+    end
+
+    def format_transactions(week)
+      (@transactions[week] || []).map do |transaction|
+        draft_picks = transaction["draft_picks"]&.map do |pick|
+          {
+            season: pick["season"],
+            round: pick["round"],
+            original_roster_id: pick["owner_id"],
+            previous_roster_id: pick["previous_owner_id"],
+            new_roster_id: pick["owner_id"]
+          }
+        end || []
+        waiver_budget = transaction["waiver_budget"]&.map do |budget|
+          {
+            amount: budget["amount"],
+            receiving_roster: budget["receiver"],
+            sending_roster: budget["sender"]
+          }
+        end || []
+
+        transaction_metadata = transaction["metadata"]
+
+        {
+          week: week,
+          transaction_id: transaction["transaction_id"],
+          status: transaction["status"],
+          type: transaction["type"],
+          created_at: transaction["created"],
+          status_updated_at: transaction["status_updated"],
+          roster_ids: transaction["roster_ids"] || [],
+          adds: transaction["adds"]&.map do |player_id, roster_id|
+            { player_id: player_id, roster_id: roster_id }
+          end || [],
+          drops: transaction["drops"]&.map do |player_id, roster_id|
+            { player_id: player_id, roster_id: roster_id }
+          end || [],
+          waiver_bid: transaction["settings"]&.dig("waiver_bid"),
+          waiver_order: transaction["settings"]&.dig("seq"),
+          draft_picks: draft_picks,
+          waiver_budget: waiver_budget,
+          metadata: transaction_metadata.is_a?(Hash) ? transaction_metadata.transform_keys(&:to_sym) : transaction_metadata,
+          created_by_user_id: transaction["creator"]
+        }
+      end
+    end
+  end
+end

data/lib/sleeper_api/user.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module SleeperApi
+  class User
+    include Helpers
+
+    # User attributes from the API.
+    ATTRIBUTES = %w[username user_id display_name avatar email cookies created currencies data_updated deleted is_bot
+                    metadata notifications pending phone real_name solicitable summoner_name summoner_region token
+                    verification].freeze
+
+    attr_reader :identifier
+
+    # @param identifier [String, Integer] Username or user ID
+    # @param client [SleeperApi::Client] HTTP client instance
+    # @raise [ArgumentError] If identifier is empty
+    # @raise [SleeperApi::Error] If user data is invalid
+    def initialize(identifier, client)
+      raise ArgumentError, "identifier must be a non-empty string" if identifier.to_s.empty?
+
+      @identifier = identifier
+      @client = client
+      @user_data = nil
+      @leagues = nil
+      @drafts = nil
+
+      fetch_user_data
+      @user_id = @user_data["user_id"] || raise(SleeperApi::Error, "Invalid user data: user_id not found")
+    end
+
+    # Dynamically define attribute readers for user data.
+    ATTRIBUTES.each do |attr|
+      define_method(attr) do
+        @user_data[attr]
+      end
+    end
+
+    # Generate avatar URL from ID.
+    #
+    # @return [String, nil] Full avatar URL or nil if no avatar
+    def avatar_url
+      avatar ? "https://sleepercdn.com/avatars/#{avatar}" : nil
+    end
+
+    # Get all leagues for a specific season.
+    #
+    # @param season [Integer] Season year (default: current year)
+    # @return [Array<Hash>] Formatted league objects
+    # @raise [ArgumentError] If season is not an integer
+    def leagues(season = Time.now.year)
+      raise ArgumentError, "season must be a valid year" unless season.is_a?(Integer)
+
+      fetch_leagues(season) unless @leagues
+    end
+
+    # Get all rosters for this user across all leagues in a season.
+    #
+    # @param season [Integer] Season year (default: current year)
+    # @return [Array<Hash>] Formatted roster objects from all leagues
+    # @raise [ArgumentError] If season is not an integer
+    def rosters(season = Time.now.year)
+      raise ArgumentError, "season must be a valid year" unless season.is_a?(Integer)
+
+      fetch_leagues(season) unless @leagues
+      (@leagues || []).flat_map do |league|
+        league_instance = League.new(league[:league_id], @client, no_data: true)
+        league_instance.rosters(user_id: @user_id)
+      end
+    end
+
+    # Get all drafts for a specific season with enhanced metadata.
+    #
+    # @param season [Integer] Season year (default: current year)
+    # @return [Array<Hash>] Formatted draft objects with league info
+    # @raise [ArgumentError] If season is not an integer
+    def drafts(season = Time.now.year)
+      raise ArgumentError, "season must be a valid year" unless season.is_a?(Integer)
+
+      fetch_drafts(season) unless @drafts
+      format_drafts
+    end
+
+    # Get a summary of user's league participation.
+    #
+    # @param season [Integer] Season year (default: current year)
+    # @return [Hash] Summary statistics
+    def summary(season = Time.now.year)
+      leagues_data = leagues(season)
+      rosters_data = rosters(season)
+
+      {
+        season: season,
+        total_leagues: leagues_data.length,
+        winning_record: rosters_data.select { |r| r[:wins] > r[:losses] },
+        total_wins: rosters_data.sum { |r| r[:wins] },
+        total_losses: rosters_data.sum { |r| r[:losses] },
+        total_ties: rosters_data.sum { |r| r[:ties] },
+        avg_record: if rosters_data.any?
+                      {
+                        wins: rosters_data.sum { |r| r[:wins].to_f } / rosters_data.length,
+                        losses: rosters_data.sum { |r| r[:losses].to_f } / rosters_data.length,
+                        ties: rosters_data.sum { |r| r[:ties].to_f } / rosters_data.length
+                      }
+                    end,
+        best_team: rosters_data.max_by { |r| r[:wins].to_i - r[:losses].to_i },
+        worst_team: rosters_data.min_by { |r| r[:wins].to_i - r[:losses].to_i }
+      }
+    end
+
+    private
+
+    def fetch_user_data
+      @user_data ||= @client.get_user(@identifier)
+    end
+
+    def fetch_leagues(season)
+      @leagues ||= (@client.get_user_leagues(@user_id, season: season) || []).map do |league|
+        deep_symbolize_keys(league)
+      end
+    end
+
+    def fetch_drafts(season)
+      @drafts ||= (@client.get_user_drafts(@user_id, season: season) || []).map { |draft| deep_symbolize_keys(draft) }
+    end
+
+    def format_drafts
+      (@drafts || []).map do |draft|
+        draft.merge(
+          league_name: draft.dig(:metadata, :name),
+          scoring_type: draft.dig(:metadata, :scoring_type),
+          total_teams: draft.dig(:settings, :teams),
+          rounds: draft.dig(:settings, :rounds)
+        )
+      end
+    end
+  end
+end

data/lib/sleeper_api/version.rb

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

data/lib/sleeper_api.rb

@@ -0,0 +1,87 @@
+require_relative "sleeper_api/version"
+require_relative "sleeper_api/helpers"
+require_relative "sleeper_api/client"
+require_relative "sleeper_api/league"
+require_relative "sleeper_api/user"
+require_relative "sleeper_api/draft"
+
+module SleeperApi
+  class Error < StandardError; end
+
+  class << self
+    attr_writer :configuration
+  end
+
+  # Configure the gem globally.
+  #
+  # @yieldparam [SleeperApi::Configuration] config
+  # @example
+  #   SleeperApi.configure do |config|
+  #     config.timeout = 20
+  #     config.retries = 5
+  #     config.logger = Logger.new('sleeper.log')
+  #   end
+  def self.configure
+    self.configuration ||= Configuration.new
+    yield(configuration)
+  end
+
+  # Get the configured client instance.
+  #
+  # @return [SleeperApi::Client]
+  def self.client
+    @client ||= Client.new(configuration)
+  end
+
+  # Get the global configuration.
+  #
+  # @return [SleeperApi::Configuration]
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  # Configuration for SleeperApi client behavior.
+  #
+  # @attr timeout [Integer] HTTP request timeout (10-60 seconds)
+  # @attr retries [Integer] Maximum retry attempts (0-5)
+  # @attr logger [Logger, nil] Logger for debugging requests
+  class Configuration
+    attr_accessor :logger
+    attr_reader :timeout, :retries
+
+    MIN_TIMEOUT = 10
+    MAX_TIMEOUT = 60
+    MIN_RETRIES = 0
+    MAX_RETRIES = 5
+
+    def initialize
+      @timeout = 30
+      @retries = 3
+      @logger = nil
+    end
+
+    # Set HTTP timeout with validation.
+    #
+    # @param value [Integer] Timeout in seconds
+    # @raise [SleeperApi::Error] If outside valid range
+    def timeout=(value)
+      unless value.between?(MIN_TIMEOUT, MAX_TIMEOUT)
+        raise SleeperApi::Error, "Timeout must be between #{MIN_TIMEOUT} and #{MAX_TIMEOUT} seconds"
+      end
+
+      @timeout = value
+    end
+
+    # Set retry count with validation.
+    #
+    # @param value [Integer] Number of retries
+    # @raise [SleeperApi::Error] If outside valid range
+    def retries=(value)
+      unless value.between?(MIN_RETRIES, MAX_RETRIES)
+        raise SleeperApi::Error, "Retries must be between #{MIN_RETRIES} and #{MAX_RETRIES}"
+      end
+
+      @retries = value
+    end
+  end
+end

data/sig/sleeper_api.rbs

@@ -0,0 +1,4 @@
+module SleeperApi
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

data/sleeper_api.gemspec

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "lib/sleeper_api/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "sleeper_api"
+  spec.version = SleeperApi::VERSION
+  spec.authors = ["Eruity1"]
+  spec.email = ["ethanruity@icloud.com"]
+
+  spec.summary = "Comprehensive Ruby wrapper for the Sleeper's fantasy sports API"
+  spec.description = "A comprehensive Ruby gem for interacting with Sleeper's fantasy football API. Features include league management, user profiles, draft data, matchups, transactions, player data with caching, and comprehensive error handling. Built with performance and reliability in mind for production applications."
+  spec.homepage = "https://github.com/eruity1/sleeper_api"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.6.0"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+  spec.metadata["documentation_uri"] = "#{spec.homepage}/blob/main/README.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.
+  all_files = `git ls-files`.split("\n")
+  test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+  ci_files = `git ls-files -- .github/*`.split("\n")
+
+  spec.files = all_files - test_files
+  spec.files += ["sig/sleeper_api.rbs"]
+
+  spec.files -= [
+    "players_cache.json",
+    "coverage/",
+    ".rspec_status",
+  ].select { |file| File.exist?(file) }
+
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "httparty", "~> 0.21"
+
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3.13"
+  spec.add_development_dependency "rubocop", "~> 1.80"
+  spec.add_development_dependency "rubocop-performance", "~> 1.26"
+  spec.add_development_dependency "rubocop-rspec", "~> 3.7"
+  spec.add_development_dependency "simplecov", "~> 0.21"
+  spec.add_development_dependency "webmock", "~> 3.14"
+end