ahl_scraper 0.1.1

data/lib/ahl_scraper/games.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "ahl_scraper/games/events"
+
+require "ahl_scraper/services/games/create_skaters_service"
+require "ahl_scraper/services/games/on_ice_statlines_service"
+require "ahl_scraper/services/games/penalty_shots_service"
+require "ahl_scraper/services/games/penalty_shot_statlines_service"
+require "ahl_scraper/services/games/penalty_statlines_service"
+require "ahl_scraper/services/games/scoring_statlines_service"
+require "ahl_scraper/services/games/shootout_statlines_service"
+require "ahl_scraper/services/games/team_on_ice_goals_service"
+require "ahl_scraper/services/games/time_splits_service"
+
+require "ahl_scraper/resources/games/coach"
+require "ahl_scraper/resources/games/goal"
+require "ahl_scraper/resources/games/goalie"
+require "ahl_scraper/resources/games/info"
+require "ahl_scraper/resources/games/on_ice_skater"
+require "ahl_scraper/resources/games/overtime"
+require "ahl_scraper/resources/games/penalty_shot"
+require "ahl_scraper/resources/games/penalty"
+require "ahl_scraper/resources/games/period"
+require "ahl_scraper/resources/games/referee"
+require "ahl_scraper/resources/games/shootout_attempt"
+require "ahl_scraper/resources/games/skater"
+require "ahl_scraper/resources/games/star"
+require "ahl_scraper/resources/games/team"
+
+require "ahl_scraper/resources/games/events/shot"
+
+module AhlScraper
+  module Games
+    @season_games = {}
+
+    class << self
+      def retrieve(game_id, season_type = nil)
+        Game.new(game_id, season_type: season_type)
+      end
+
+      def list(season_id)
+        @season_games[season_id.to_s] ||= SeasonGameIdsFetcher.new(season_id).call&.map { |game_data| GameListItem.new(game_data) }
+      end
+    end
+  end
+end

data/lib/ahl_scraper/games/events.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module AhlScraper
+  module Games
+    module Events
+    end
+  end
+end

data/lib/ahl_scraper/helpers/birthdate_helper.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "date"
+
+module AhlScraper
+  class BirthdateHelper
+    attr_reader :birthdate
+
+    def initialize(birthdate)
+      @birthdate = Date.parse(birthdate)
+    end
+
+    def draft_year
+      return (birthdate + (19 * 365)).year if (birthdate.month == 9 && birthdate.day > 15) || birthdate.month > 9
+
+      (birthdate + (18 * 365)).year
+    end
+
+    def current_age(round: 2)
+      ((Time.now.utc.to_datetime - birthdate.to_datetime).to_i / BigDecimal("365")).round(round)
+    end
+
+    def age_on_date(date, round: 2)
+      ((Date.parse(date).to_datetime - birthdate.to_datetime).to_i / BigDecimal("365")).round(round)
+    end
+  end
+end

data/lib/ahl_scraper/helpers/elapsed_time_helper.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module AhlScraper
+  class ElapsedTimeHelper
+    attr_reader :time
+
+    def initialize(time)
+      @time = time.to_i
+    end
+
+    def to_minutes
+      "#{time / 60}:#{(time % 60).to_s.rjust(2, '0')}"
+    end
+
+    def to_minutes_with_period
+      period_elapsed = time % 1200
+
+      ["#{period_elapsed / 60}:#{period_elapsed % 60}", (time / 1200) + 1]
+    end
+
+    alias to_min to_minutes
+    alias to_min_with_per to_minutes_with_period
+  end
+end

data/lib/ahl_scraper/helpers/ice_time_helper.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module AhlScraper
+  class IceTimeHelper
+    attr_reader :time
+
+    def initialize(time)
+      @time = time
+    end
+
+    def to_seconds
+      ice_time = time.split(":")
+      ice_time[0].to_i * 60 + ice_time[1].to_i
+    end
+
+    alias to_sec to_seconds
+  end
+end

data/lib/ahl_scraper/helpers/parameterize_helper.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module AhlScraper
+  class ParameterizeHelper
+    attr_reader :string, :separator, :preserve_case
+
+    def initialize(string, separator: "-", preserve_case: false)
+      @string = string
+      @separator = separator
+      @preserve_case = preserve_case
+    end
+
+    def call
+      parameterized_string = string.dup.to_s
+
+      parameterized_string.gsub!(/[^a-zA-Z0-9\-_]+/, separator)
+
+      unless separator.nil? || separator.empty?
+        if separator == "-"
+          re_duplicate_separator        = /-{2,}/
+          re_leading_trailing_separator = /^-|-$/
+        else
+          re_sep = Regexp.escape(separator)
+          re_duplicate_separator = /#{re_sep}{2,}/
+          re_leading_trailing_separator = /^#{re_sep}|#{re_sep}$/
+        end
+        parameterized_string.gsub!(re_duplicate_separator, separator)
+        parameterized_string.gsub!(re_leading_trailing_separator, "")
+      end
+
+      parameterized_string.downcase! unless preserve_case
+      parameterized_string
+    end
+  end
+end

data/lib/ahl_scraper/helpers/period_time_helper.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module AhlScraper
+  class PeriodTimeHelper
+    attr_reader :time, :period
+
+    def initialize(time, period = nil)
+      @time = time
+      @period = period.to_i
+    end
+
+    def to_period_seconds
+      period_time = time.split(":")
+      period_time[0].to_i * 60 + period_time[1].to_i
+    end
+
+    def to_time_elapsed
+      period_time = time.split(":")
+      period_time[0].to_i * 60 + period_time[1].to_i + ((period - 1) * 1200)
+    end
+
+    alias to_sec to_period_seconds
+    alias to_elapsed to_time_elapsed
+  end
+end

data/lib/ahl_scraper/helpers/season_dates_helper.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module AhlScraper
+  class SeasonDatesHelper
+    DATE_EXCEPTIONS = {
+      68 => { start_date: "Mon, Feb 1", end_date: "Sat, Jun 8" },
+    }.freeze
+
+    SEASON_MONTH_KEY = {
+      regular: { start_month: "10", end_month: "4" },
+      playoffs: { start_month: "4", end_month: "6" },
+    }.freeze
+  end
+end

data/lib/ahl_scraper/player_games.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "ahl_scraper/fetchers/player_games/data_fetcher"
+
+module AhlScraper
+  module PlayerGames
+    @season_games = {}
+
+    class << self
+      def list(player_id, season_id)
+        @season_games["#{player_id}-#{season_id}"] ||= DataFetcher.new(player_id, season_id).call&.map do |player_data|
+          player_data[:position] == "G" ? GoalieGameListItem.new(player_data) : SkaterGameListItem.new(player_data)
+        end
+
+        @season_games["#{player_id}-#{season_id}"]
+      end
+    end
+  end
+end

data/lib/ahl_scraper/players.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module AhlScraper
+  module Players
+    class << self
+      def retrieve(player_id)
+        player_data = PlayerDataFetcher.new(player_id).call
+        Player.new(player_data)
+      end
+    end
+  end
+end

data/lib/ahl_scraper/playoff_brackets.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "ahl_scraper/resources/playoff_brackets/game"
+require "ahl_scraper/resources/playoff_brackets/round"
+require "ahl_scraper/resources/playoff_brackets/series"
+require "ahl_scraper/resources/playoff_brackets/team"
+
+module AhlScraper
+  module PlayoffBrackets
+    class << self
+      def retrieve(season_id)
+        bracket_data = PlayoffBracketDataFetcher.new(season_id).call
+        PlayoffBracket.new(bracket_data)
+      end
+    end
+  end
+end

data/lib/ahl_scraper/resource.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module AhlScraper
+  class Resource
+    include Enumerable
+
+    def initialize(raw_data, opts = {})
+      @raw_data = raw_data
+      @opts = opts
+    end
+
+    def values
+      @values ||= (self.class.instance_methods(false) - %i[to_json inspect each keys [] values]).map do |m|
+        [m, send(m)]
+      end.to_h.transform_keys(&:to_sym)
+    end
+
+    def inspect
+      "#<#{self.class.to_s.split('::').last}:0x#{object_id.to_s(16)} #{values}>"
+    end
+
+    def [](key)
+      values[key.to_sym]
+    end
+
+    def keys
+      values.keys
+    end
+
+    def to_json(*_opts)
+      JSON.generate(values)
+    end
+
+    def each(&blk)
+      values.each(&blk)
+    end
+  end
+end

data/lib/ahl_scraper/resources/game.rb

@@ -0,0 +1,373 @@
+# frozen_string_literal: true
+
+module AhlScraper
+  class Game < Resource # rubocop:disable Metrics/ClassLength
+    include Enumerable
+
+    IRREGULAR_GAMES = {
+      "1022174" => { status: "result_void", start_time_in_seconds: 0, end_time_in_seconds: 1200 },
+    }.freeze
+
+    ATTRIBUTES = %i[
+      game_id
+      season_type
+      info
+      current_time
+      current_period
+      current_period_number
+      season_id
+      played
+      in_progress
+      referees
+      home_coaches
+      away_coaches
+      home_team
+      away_team
+      winning_team
+      three_stars
+      home_skaters
+      away_skaters
+      home_goalies
+      away_goalies
+      home_roster
+      away_roster
+      goals
+      penalties
+      penalty_shots
+      periods
+      overtimes
+      overtime
+      home_shootout_attempts
+      away_shootout_attempts
+      home_penalty_shots
+      away_penalty_shots
+      shootout
+    ].freeze
+
+    attr_reader(*ATTRIBUTES)
+
+    def initialize(game_id, opts = {})
+      @game_id = game_id
+      @raw_data = GameDataFetcher.new(game_id).call
+      @raw_event_data = GameEventDataFetcher.new(game_id).call
+      @season_type = opts[:season_type] || SeasonTypeFetcher.new(@raw_data[:details][:seasonId]).call
+    end
+
+    def values
+      @values ||= ATTRIBUTES.index_with do |m|
+        send(m)
+      end.transform_keys(&:to_sym)
+    end
+
+    def status
+      @status ||= set_game_status
+    end
+
+    def info
+      @info ||= Games::Info.new(@raw_data[:details], { name: "#{away_team.abbreviation} @ #{home_team.abbreviation}" })
+    end
+
+    def current_time
+      @current_time ||= set_current_game_time
+    end
+
+    def current_period
+      @current_period ||= set_current_game_period
+    end
+
+    def current_period_number
+      @current_period_number ||= @raw_data[:periods].length
+    end
+
+    def season_id
+      @season_id ||= @raw_data[:details][:seasonId].to_i
+    end
+
+    def referees
+      @referees ||= Array((@raw_data[:referees] + @raw_data[:linesmen])).uniq { |referee| referee.values_at(:lastName, :firstName, :jerseyNumber) }
+        .map { |r| Games::Referee.new(r) }
+    end
+
+    def three_stars
+      @three_stars ||= Array(@raw_data[:mostValuablePlayers]).map.with_index { |t, i| Games::Star.new(t, { number: i + 1 }) }
+    end
+
+    def home_coaches
+      @home_coaches ||= Array(@raw_data[:homeTeam][:coaches]).uniq { |coach| coach.values_at(:lastName, :firstName) }
+        .map { |coach| Games::Coach.new(coach, { team_id: home_team.id }) }
+    end
+
+    def away_coaches
+      @away_coaches ||= Array(@raw_data[:visitingTeam][:coaches]).uniq { |coach| coach.values_at(:lastName, :firstName) }
+        .map { |coach| Games::Coach.new(coach, { team_id: away_team.id }) }
+    end
+
+    def home_team
+      @home_team ||= Games::Team.new(
+        @raw_data[:homeTeam],
+        {
+          home_team: true,
+          goals: raw_goals,
+          current_state: current_state,
+          game_properties: game_properties,
+          shots: raw_period_shots,
+          goal_totals: raw_period_goals,
+          winning_team_id: winning_team_id,
+        }
+      )
+    end
+
+    def away_team
+      @away_team ||= Games::Team.new(
+        @raw_data[:visitingTeam],
+        {
+          home_team: false,
+          goals: raw_goals,
+          current_state: current_state,
+          game_properties: game_properties,
+          shots: raw_period_shots,
+          goal_totals: raw_period_goals,
+          winning_team_id: winning_team_id,
+        }
+      )
+    end
+
+    def winning_team
+      @winning_team ||=
+        if status == "finished"
+          winning_team_id == home_team.id ? home_team : away_team
+        end
+    end
+
+    def home_skaters
+      @home_skaters ||= Games::CreateSkatersService.new(
+        @raw_data[:homeTeam][:skaters],
+        raw_goals,
+        raw_penalties,
+        raw_home_shootout_attempts,
+        @raw_data[:penaltyShots][:homeTeam],
+        { home_team: true, team_id: home_team.id, team_abbreviation: home_team.abbreviation, game_date: @raw_data[:details][:date] }
+      ).call
+    end
+
+    def away_skaters
+      @away_skaters ||= Games::CreateSkatersService.new(
+        Array(@raw_data[:visitingTeam][:skaters]),
+        raw_goals,
+        raw_penalties,
+        raw_away_shootout_attempts,
+        @raw_data[:penaltyShots][:visitingTeam],
+        { home_team: false, team_id: away_team.id, team_abbreviation: away_team.abbreviation, game_date: @raw_data[:details][:date] }
+      ).call
+    end
+
+    def home_goalies
+      @home_goalies ||= Array(@raw_data[:homeTeam][:goalies]).map do |g|
+        Games::Goalie.new(
+          g,
+          {
+            team_id: home_team.id,
+            home_team: true,
+            shootout_data: @raw_data.dig(:shootoutDetails, :visitingTeamShots),
+            penalty_shot_data: @raw_data.dig(:penaltyShots, :visitingTeam),
+            game_date: @raw_data[:details][:date],
+          }
+        )
+      end
+    end
+
+    def away_goalies
+      @away_goalies ||= Array(@raw_data[:visitingTeam][:goalies]).map do |g|
+        Games::Goalie.new(
+          g,
+          {
+            team_id: away_team.id,
+            home_team: false,
+            shootout_data: @raw_data.dig(:shootoutDetails, :homeTeamShots),
+            penalty_shot_data: @raw_data.dig(:penaltyShots, :homeTeam),
+            game_date: @raw_data[:details][:date],
+          }
+        )
+      end
+    end
+
+    def home_roster
+      @home_roster ||= [*home_skaters, *home_goalies]
+    end
+
+    def away_roster
+      @away_roster ||= [*away_skaters, *away_goalies]
+    end
+
+    def goals
+      @goals ||= raw_goals.map.with_index { |g, i| Games::Goal.new(g, { number: i + 1 }) }
+    end
+
+    def penalties
+      @penalties ||= raw_penalties.map.with_index { |pn, i| Games::Penalty.new(pn, { number: i + 1 }) }
+    end
+
+    def penalty_shots
+      @penalty_shots ||= (home_penalty_shots || []) + (away_penalty_shots || [])
+    end
+
+    def home_penalty_shots
+      @home_penalty_shots ||= Games::PenaltyShotsService.new(@raw_data[:penaltyShots][:homeTeam]).call
+    end
+
+    def away_penalty_shots
+      @away_penalty_shots ||= Games::PenaltyShotsService.new(@raw_data[:penaltyShots][:visitingTeam]).call
+    end
+
+    def periods
+      @periods ||= Array(@raw_data[:periods][0..2]).map { |per| Games::Period.new(per) }
+    end
+
+    def overtimes
+      @overtimes ||= Array(@raw_data[:periods][3..-1]).map { |o| Games::Overtime.new(o, { regular_season: season_type == :regular }) }
+    end
+
+    def overtime?
+      @overtime ||= overtimes.length.positive?
+    end
+
+    def shootout_attempts
+      @shootout_attempts ||= [*home_shootout_attempts, *away_shootout_attempts]
+    end
+
+    def home_shootout_attempts
+      @home_shootout_attempts ||= raw_home_shootout_attempts&.map&.with_index do |att, i|
+        Games::ShootoutAttempt.new(att, { number: i + 1, opposing_team: find_opposing_team(att[:shooterTeam][:id].to_i) })
+      end || []
+    end
+
+    def away_shootout_attempts
+      @away_shootout_attempts ||= raw_away_shootout_attempts&.map&.with_index do |att, i|
+        Games::ShootoutAttempt.new(att, { number: i + 1, opposing_team: find_opposing_team(att[:shooterTeam][:id].to_i) })
+      end || []
+    end
+
+    def shootout?
+      @shootout ||= @raw_data[:hasShootout] == true
+    end
+
+    def played?
+      @played ||= status == "finished"
+    end
+
+    def in_progress?
+      @in_progress ||= status == "in_progress"
+    end
+
+    def ended_in
+      @ended_in ||=
+        if shootout?
+          "SO"
+        elsif overtime?
+          "OT"
+        else
+          "REG"
+        end
+    end
+
+    private
+
+    def raw_goals
+      @raw_goals ||= Array(@raw_data[:periods]).map { |a| a[:goals] }.flatten
+    end
+
+    def raw_penalties
+      @raw_penalties ||= Array(@raw_data[:periods]).map { |a| a[:penalties] }.flatten
+    end
+
+    def raw_period_shots
+      @raw_period_shots ||= Array(@raw_data[:periods]).map do |period|
+        { home: period[:stats][:homeShots].to_i, away: period[:stats][:visitingShots].to_i }
+      end
+    end
+
+    def raw_period_goals
+      @raw_period_goals ||= Array(@raw_data[:periods]).map do |period|
+        { home: period[:stats][:homeGoals].to_i, away: period[:stats][:visitingGoals].to_i }
+      end
+    end
+
+    def raw_home_shootout_attempts
+      @raw_home_shootout_attempts ||= @raw_data.dig(:shootoutDetails, :homeTeamShots)
+    end
+
+    def raw_away_shootout_attempts
+      @raw_away_shootout_attempts ||= @raw_data.dig(:shootoutDetails, :visitingTeamShots)
+    end
+
+    def find_opposing_team(team_id)
+      team_id == home_team.id ? away_team : home_team
+    end
+
+    def winning_team_id
+      @winning_team_id ||= status == "finished" ? set_winning_team_id : nil
+    end
+
+    def set_winning_team_id
+      if @raw_data[:homeTeam][:stats][:goals] > @raw_data[:visitingTeam][:stats][:goals]
+        @raw_data[:homeTeam][:info][:id]
+      elsif @raw_data[:homeTeam][:stats][:goals] < @raw_data[:visitingTeam][:stats][:goals]
+        @raw_data[:visitingTeam][:info][:id]
+      else
+        @raw_data[:shootoutDetails][:winningTeam][:id]
+      end
+    end
+
+    def current_state
+      @current_state ||= {
+        status: status,
+        period: current_period,
+        period_number: current_period_number,
+        time: current_time,
+        shootout: shootout?,
+        overtime: overtime?,
+      }
+    end
+
+    def game_properties
+      @game_properties ||= {
+        playoffs: @season_type == :playoffs,
+        periods: periods.length,
+        overtime_periods: overtimes.length,
+        game_start_time_in_seconds: IRREGULAR_GAMES.dig(game_id.to_s, :start_time_in_seconds),
+        game_end_time_in_seconds: IRREGULAR_GAMES.dig(game_id.to_s, :end_time_in_seconds),
+      }
+    end
+
+    def set_game_status
+      irregular_game_status = IRREGULAR_GAMES.dig(game_id.to_s, :status)
+      return irregular_game_status if irregular_game_status
+
+      # return "forfeited" if game is a forfeit, need to figure this out if it happens
+
+      return "finished" if @raw_data[:details][:final] == "1"
+
+      return "in_progress" if @raw_data[:details][:started] == "1"
+
+      "not_started"
+    end
+
+    def set_current_game_time
+      return if /Final/.match?(@raw_data[:details][:status])
+
+      game_time = @raw_data[:details][:status].match(/\d{1,2}:\d{2}/).to_s
+      return if game_time.empty?
+
+      game_time
+    end
+
+    def set_current_game_period
+      return if /Final/.match?(@raw_data[:details][:status])
+
+      period = @raw_data[:details][:status].match(/(1st|2nd|3rd|OT|[1-9]?[0-9]OT|SO)/).to_s
+      return if period.empty?
+
+      period
+    end
+  end
+end