sports_data_api 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: daa6b600a49f7cc130a5a54f361dbd390340c145
-  data.tar.gz: 52f55a92b4e598cbbce507f82e24c49b7e2de667
+  metadata.gz: 955753065636d3442bf1601d37c3281fd20b3c8b
+  data.tar.gz: 591bae0973f4af66eba5a8449163383839eb841f
 SHA512:
-  metadata.gz: 21fc4f3db62ace35e8261ac078e73afedcaef5849b0e81726fdf8a3bdc42b7dcdc6b54cb8b18ac6aada7434b21f53b5d129845e2b018b2f5203d2c1817a4f8e4
-  data.tar.gz: a76ab1ccea8466ca38bb448896f0c380355512ca38b309bd51ba1bf41e3665577f50636c7ca8daeefffbcd038d4acae93479574b2e974c4a6afec72c14e9d325
+  metadata.gz: aa67111339cc2fceec855ed582f39888f04cffb0ecd8d5af4aa68be62e0197726de446f69e299e99d073c83adfc70a8db6f56a27e886f704933c8c45c938da07
+  data.tar.gz: 7b20aa4149a074f663926b5447c48a7f4d82ac81f500df04b842888362b3124c95391dd0a2988fcb763cab1c9e69fc00ce6bab7d7c0192c0784f372ec8a5bb5a

data/.travis.yml

@@ -2,5 +2,6 @@ language: ruby
 rvm:
   - 1.9.3
   - 2.0.0
-  - 2.1.0
+  - 2.1
+  - 2.2
   - ruby-head

data/lib/sports_data_api.rb

@@ -48,6 +48,7 @@ module SportsDataApi
 
   autoload :Stats,       File.join(LIBRARY_PATH, 'stats')
   autoload :Nfl,         File.join(LIBRARY_PATH, 'nfl')
+  autoload :Ncaafb,      File.join(LIBRARY_PATH, 'ncaafb')
   autoload :Nba,         File.join(LIBRARY_PATH, 'nba')
   autoload :Mlb,         File.join(LIBRARY_PATH, 'mlb')
   autoload :Nhl,         File.join(LIBRARY_PATH, 'nhl')

data/lib/sports_data_api/ncaafb.rb

@@ -0,0 +1,84 @@
+module SportsDataApi
+  module Ncaafb
+    class Exception < ::Exception
+    end
+
+    DIR = File.join(File.dirname(__FILE__), 'ncaafb')
+    BASE_URL = 'http://api.sportsdatallc.org/ncaafb-%{access_level}%{version}'
+    DEFAULT_VERSION = 1
+    SPORT = :ncaafb
+
+    autoload :Division, File.join(DIR, 'division')
+    autoload :Team, File.join(DIR, 'team')
+    autoload :Teams, File.join(DIR, 'teams')
+    autoload :Player, File.join(DIR, 'player')
+    autoload :Game, File.join(DIR, 'game')
+    autoload :Games, File.join(DIR, 'games')
+    autoload :Week, File.join(DIR, 'week')
+    autoload :Season, File.join(DIR, 'season')
+    autoload :Venue, File.join(DIR, 'venue')
+    autoload :Broadcast, File.join(DIR, 'broadcast')
+    autoload :Weather, File.join(DIR, 'weather')
+
+    ##
+    # Fetches Ncaafb season schedule for a given year and season
+    def self.schedule(year, season, version = DEFAULT_VERSION)
+      season = season.to_s.upcase.to_sym
+      raise SportsDataApi::Ncaafb::Exception.new("#{season} is not a valid season") unless Season.valid?(season)
+
+      response = self.response_json(version, "/#{year}/#{season}/schedule.json")
+
+      return Season.new(response)
+    end
+
+    ##
+    # Fetches Ncaafb boxscore for a given game
+    def self.boxscore(year, season, week, home, away, version = DEFAULT_VERSION)
+      season = season.to_s.upcase.to_sym
+      raise SportsDataApi::Ncaafb::Exception.new("#{season} is not a valid season") unless Season.valid?(season)
+
+      response = self.response_json(version, "/#{year}/#{season}/#{week}/#{away}/#{home}/boxscore.json")
+
+      return Game.new(year, season, week, response)
+    end
+
+    ##
+    # Fetches statistics for a given Ncaafb game
+    def self.game_statistics(year, season, week, home, away, version = DEFAULT_VERSION)
+      season = season.to_s.upcase.to_sym
+      raise SportsDataApi::Ncaafb::Exception.new("#{season} is not a valid season") unless Season.valid?(season)
+
+      response = self.response_json(version, "/#{year}/#{season}/#{week}/#{away}/#{home}/statistics.json")
+
+      return Game.new(year, season, week, response)
+    end
+
+    ##
+    # Fetches all Ncaafb teams
+    def self.teams(division, version = DEFAULT_VERSION)
+      raise SportsDataApi::Ncaafb::Exception.new("#{division} is not a valid season") unless Division.valid?(division)
+      response = self.response_json(version, "/teams/#{division}/hierarchy.json")
+
+      return Teams.new(response)
+    end
+
+    ##
+    # Fetches Ncaafb weekly schedule for a given year, season and week
+    def self.weekly(year, season, week, version = DEFAULT_VERSION)
+      season = season.to_s.upcase.to_sym
+      raise SportsDataApi::Ncaafb::Exception.new("#{season} is not a valid season") unless Season.valid?(season)
+
+      response = self.response_json(version, "/#{year}/#{season}/#{week}/schedule.json")
+
+      return Games.new(year, season, week, response)
+    end
+
+    private
+
+    def self.response_json(version, url)
+      base_url = BASE_URL % { access_level: SportsDataApi.access_level(SPORT), version: version }
+      response = SportsDataApi.generic_request("#{base_url}#{url}", SPORT)
+      MultiJson.load(response.to_s)
+    end
+  end
+end

data/lib/sports_data_api/ncaafb/broadcast.rb

@@ -0,0 +1,14 @@
+module SportsDataApi
+  module Ncaafb
+    class Broadcast
+      attr_reader :network, :satellite, :internet
+      def initialize(broadcast_hash)
+        if broadcast_hash
+          @network = broadcast_hash['network']
+          @satellite = broadcast_hash['satellite'] || ''
+          @internet = broadcast_hash['internet']
+        end
+      end
+    end
+  end
+end

data/lib/sports_data_api/ncaafb/division.rb

@@ -0,0 +1,14 @@
+module SportsDataApi
+  module Ncaafb
+    class Division
+      ##
+      # Check if the requested division is a valid
+      # Ncaafb division type.
+      #
+      # The only valid types are: :REG
+      def self.valid?(division)
+        [:FBS,:FCS, :D2, :D3, :NAIA, :USCAA].include?(division)
+      end
+    end
+  end
+end

data/lib/sports_data_api/ncaafb/game.rb

@@ -0,0 +1,78 @@
+module SportsDataApi
+  module Ncaafb
+    class Game
+      attr_reader :id, :scheduled, :home, :home_team, :away,
+        :away_team, :status, :quarter, :clock, :venue, :broadcast, :weather,
+        :year, :season, :week
+
+      def initialize(year, season, week, game_hash)
+        @year = year
+        @season = season
+        @week = week
+
+        @id = game_hash['id']
+        @scheduled = Time.parse game_hash['scheduled']
+        @home = game_hash['home'] || game_hash['home_team']['id']
+        @away = game_hash['away'] || game_hash['away_team']['id']
+        @status = game_hash['status']
+        @quarter = game_hash['quarter'].to_i
+        @clock = game_hash['clock']
+
+        @home_team = Team.new(game_hash['home_team'])
+        @away_team = Team.new(game_hash['away_team'])
+        @venue = Venue.new(game_hash['venue'])
+        @broadcast = Broadcast.new(game_hash['broadcast'])
+        @weather = Weather.new(game_hash['weather'])
+      end
+
+      ##
+      # Wrapper for Ncaafb.statistics
+      def statistics
+        Ncaafb.game_statistics(year, season, week, home, away, 1)
+      end
+
+      ##
+      # Wrapper for Ncaafb.summary
+      # TODO
+      def summary
+        raise NotImplementedError
+      end
+
+      ##
+      # Wrapper for Ncaafb.pbp (Ncaafb.play_by_play)
+      # TODO
+      def pbp
+        raise NotImplementedError
+      end
+
+      ##
+      # Wrapper for Ncaafb.boxscore these helper methods are used
+      # to provide similar functionality as the links attribute
+      # found in the weekly schedule example.
+      def boxscore
+        Ncaafb.boxscore(year, season, week, home, away, 1)
+      end
+
+      ##
+      # Wrapper for Ncaafb.roster
+      # TODO
+      def roster
+        raise NotImplementedError
+      end
+
+      ##
+      # Wrapper for Ncaafb.injuries
+      # TODO
+      def injuries
+        raise NotImplementedError
+      end
+
+      ##
+      # Wrapper for Ncaafb.depthchart
+      # TODO
+      def depthchart
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/sports_data_api/ncaafb/games.rb

@@ -0,0 +1,28 @@
+module SportsDataApi
+  module Ncaafb
+    class Games
+      include Enumerable
+      attr_reader :games, :year, :season, :week
+
+      def initialize(year, season, week, games_hash)
+        @year = year
+        @season = season
+        @week = week
+
+        @games = games_hash['games'].map do |game_hash|
+          Game.new(@year, @season, @week, game_hash)
+        end
+      end
+
+      def each &block
+        @games.each do |game|
+          if block_given?
+            block.call game
+          else
+            yield game
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sports_data_api/ncaafb/injuries.rb

@@ -0,0 +1,9 @@
+module SportsDataApi
+  module Ncaafb
+    class Injuries
+      include Enumerable
+      attr_reader :injuries
+
+    end
+  end
+end

data/lib/sports_data_api/ncaafb/player.rb

@@ -0,0 +1,13 @@
+module SportsDataApi
+  module Ncaafb
+    class Player
+      def initialize(json)
+        player_ivar = self.instance_variable_set("@player", {})
+        self.class.class_eval { attr_reader :"player" }
+        json.each_pair do | attr_name, attr_value|
+          player_ivar[attr_name.to_sym] = attr_value
+        end
+      end
+    end
+  end
+end

data/lib/sports_data_api/ncaafb/season.rb

@@ -0,0 +1,25 @@
+module SportsDataApi
+  module Ncaafb
+    class Season
+      attr_reader :year, :type, :weeks
+
+      def initialize(season_hash)
+        @weeks = []
+        @year = season_hash['season']
+        @type = season_hash['type'].to_sym
+        @weeks = season_hash['weeks'].map do |week_hash|
+          Week.new(@year, @type, week_hash)
+        end
+      end
+
+      ##
+      # Check if the requested season is a valid
+      # Ncaafb season type.
+      #
+      # The only valid types are: :REG
+      def self.valid?(season)
+        [:REG].include?(season)
+      end
+    end
+  end
+end

data/lib/sports_data_api/ncaafb/team.rb

@@ -0,0 +1,86 @@
+module SportsDataApi
+  module Ncaafb
+    class Team
+      attr_reader :id, :name, :conference, :division, :market, :remaining_challenges,
+                  :remaining_timeouts, :score, :quarters, :venue, :points, :statistics, :players, :subdivision
+
+      def initialize(team_hash, conference = nil, division = nil, subdivision = nil)
+        if team_hash
+          @id = team_hash['id']
+          @name = team_hash['name']
+          @conference = conference
+          @division = division
+          @subdivision = subdivision
+          @market = team_hash['market']
+          @remaining_challenges = team_hash['remaining_challenges']
+          @remaining_timeouts = team_hash['remaining_timeouts']
+          @quarters = []
+          if team_hash['scoring']
+            team_hash['scoring'].each do |scoring_hash|
+              @quarters[scoring_hash['quarter']-1] = scoring_hash['points']
+            end
+          end
+          @quarters = @quarters.fill(0, @quarters.size, 4 - @quarters.size)
+
+          # Parse the Venue data if it exists
+          if team_hash.key?('venue')
+            @venue = Venue.new(team_hash['venue'])
+          end
+
+          if team_hash['statistics']
+            @statistics = parse_team_statistics(team_hash['statistics'])
+            @players = parse_player_statistics(team_hash['statistics'])
+          end
+          @points = team_hash['points'] || score
+        end
+      end
+
+      # Sum the score of each quarter
+      def score
+        @quarters.inject(:+)
+      end
+
+      ##
+      # Compare the Team with another team
+      def ==(other)
+        # Must have an id to compare
+        return false if self.id.nil?
+
+        if other.is_a? SportsDataApi::Ncaafb::Team
+          return false if other.id.nil?
+          self.id === other.id
+        elsif other.is_a? Symbol
+          self.id.to_sym === other
+        else
+          super(other)
+        end
+      end
+
+      private
+
+      def parse_team_statistics(stats_hash)
+        stats = {}
+        stats_hash.keys.each do |key|
+          stats[key] = stats_hash[key]['team']
+        end
+        stats
+      end
+
+      def parse_player_statistics(stats_hash)
+        players = []
+        stats_hash.keys.each do |key|
+          next if !stats_hash[key]['players']
+          stats_hash[key]['players'].each do |p|
+            player = players.select{|a| a['id'] == p['id']}.first || {}
+            players << player if !players.select{|a| a['id'] == p['id']}.first
+            ['id', 'name', 'jersey', 'position'].each do |k|
+              player[k] = p.delete(k)
+            end
+            player[key] = p
+          end
+        end
+        players
+      end
+    end
+  end
+end

data/lib/sports_data_api/ncaafb/teams.rb

@@ -0,0 +1,101 @@
+module SportsDataApi
+  module Ncaafb
+    class Teams
+      include Enumerable
+
+      attr_reader :conferences, :subdivisions, :divisions
+
+      def initialize(teams_hash)
+        @teams = []
+        @allowed_divisions = []
+        @allowed_conferences = []
+        @allowed_subdivisions = []
+        did = teams_hash['id']
+        teams_hash['conferences'].each do |conference_hash|
+          # Conference ID. e.g ACC
+          cid = conference_hash['id']
+          @teams << Array(conference_hash['teams']).map { |team_hash| Team.new(team_hash, cid) }
+
+          # If Sub Division
+          Array(conference_hash['subdivisions']).each do |subdivision|
+            # SUB Division ID, e.g., ACC-ATLANTIC
+            sdid = subdivision['id']
+            @teams << subdivision['teams'].map { |team_hash| Team.new(team_hash, cid, did, sdid) }
+          end
+        end
+
+        @teams.flatten!
+
+        uniq_conferences = @teams.map { |team| team.conference.upcase }.uniq
+        @allowed_conferences = concat_allowed_methods(uniq_conferences)
+        @conferences = uniq_conferences.map(&:to_sym)
+
+        @divisions = select_divisions_by_type(:division)
+        @subdivisions = select_divisions_by_type(:subdivision)
+
+        @allowed_divisions.concat(concat_allowed_methods(@divisions))
+        @allowed_subdivisions.concat(concat_allowed_methods(@subdivisions))
+      end
+
+
+
+      def [](search_index)
+        found_index = @teams.index(search_index)
+        unless found_index.nil?
+          @teams[found_index]
+        end
+      end
+
+      ##
+      #
+      def respond_to?(method)
+        @allowed_conferences.include?(method) || @allowed_divisions.include?(method) || @allowed_subdivisions
+      end
+
+      ##
+      #
+      def method_missing(method, *args, &block)
+        case true
+        when @allowed_conferences.include?(method)
+          select_by(:conference, method)
+        when @allowed_divisions.include?(method)
+          select_by(:division, method)
+        when @allowed_subdivisions.include?(method)
+          select_by(:subdivision, method)
+        else
+          super(method, *args, &block)
+        end
+      end
+
+
+
+      ##
+      # Make the class Enumerable
+      def each(&block)
+        @teams.each do |team|
+          if block_given?
+            block.call team
+          else
+            yield team
+          end
+        end
+      end
+      private
+
+      def select_by(type, method)
+        normalize_method = method.downcase.to_sym
+        @teams.select do |team|
+          normalize_method == team.send(type).to_s.downcase.to_sym
+        end
+      end
+
+      def select_divisions_by_type(division_type)
+        (@teams.map { |team| team.send(division_type).to_s.upcase.to_sym }.uniq - [:"", nil])
+      end
+
+      def concat_allowed_methods(list)
+        list.map { |str| str.to_sym }.concat(list.map { |str| str.downcase.to_sym })
+      end
+    end
+  end
+end