football_api 0.0.4

data/lib/football_api/match_summary.rb

@@ -0,0 +1,39 @@
+module FootballApi
+  class MatchSummary
+
+    attr_accessor :id, :local_team_goals, :local_team_yellowcards, :local_team_redcards,
+                  :visitor_team_goals, :visitor_team_yellowcards, :visitor_team_redcards
+
+    # For the teams goals, the api returns an empty array
+    # when there are no goals.
+    # Goals is an hash if there are goals to present.
+    def initialize(hash = {})
+      @id = hash[:id]
+
+      @local_team_goals = parse_team_goals(hash[:localteam])
+      @local_team_yellowcards = parse_cards(hash[:localteam][:yellowcards], :yellow)
+      @local_team_redcards = parse_cards(hash[:localteam][:redcards], :red)
+
+      @visitor_team_goals = parse_team_goals(hash[:visitorteam])
+      @visitor_team_yellowcards = parse_cards(hash[:visitorteam][:yellowcards], :yellow)
+      @visitor_team_redcards = parse_cards(hash[:visitorteam][:redcards], :red)
+    end
+
+    def parse_team_goals(hash = {})
+      return [] if !hash[:goals] || hash[:goals].is_a?(Array) || !hash[:goals][:player]
+
+      Array(hash[:goals][:player]).map do |player|
+        FootballApi::Goal.new(player.merge(score: player.to_s.to_i))
+      end
+    end
+
+    # If the cards struct has no members, its type is an array, so we must do
+    # the type validation before sending it to new.
+    # Like with the goals, the only way to iterpolate through all the records
+    # is with the hash key.
+    def parse_cards(hash, type)
+      return [] if !hash.is_a?(Hash) || !hash[:player]
+      Array(hash[:player]).map { |card| FootballApi::Card.new(card.merge(type: type)) }
+    end
+  end
+end

data/lib/football_api/match_team.rb

@@ -0,0 +1,22 @@
+module FootballApi
+  class MatchTeam
+
+    attr_accessor :id, :players
+
+    def initialize(hash = {}, key)
+      @id = hash[:comm_match_id]
+      @players = parse_players(hash, key)
+    end
+
+    def parse_players(hash = {}, key)
+      players = []
+      Array(hash[:comm_match_teams][key][:player]).each do |player|
+        players << FootballApi::Player.new(player)
+      end
+      Array(hash[:comm_match_subs][key][:player]).each do |player|
+        players << FootballApi::Player.new(player)
+      end
+      players
+    end
+  end
+end

data/lib/football_api/mixins/requestable.rb

@@ -0,0 +1,19 @@
+module FootballApi
+  module Requestable
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      attr_accessor :action, :json_id, :params_method
+
+      ##
+      # Options can be any of the class attributes
+      def api_options(options = {})
+        self.action  = options.delete(:action).to_s if options[:action]
+        self.json_id = options.delete(:json_key) if options[:json_key]
+        self.params_method = options.delete(:action_params)
+      end
+    end
+  end
+end

data/lib/football_api/mixins/symbolizer.rb

@@ -0,0 +1,59 @@
+module FootballApi
+  module Symbolizer
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    HASH_OR_ARRAY_KEYS = %i(player substitution comment)
+
+    module ClassMethods
+      # Custom deep symbolize of an hash
+      # So we can override the mess of some footbal-api arrays
+      def custom_deep_symbolic_hash(hash)
+        {}.tap do |h|
+          Hash(hash).each do |key, value|
+            key = symbolyze_key(key)
+            h[key] = map_value(key, value)
+          end
+        end
+      end
+
+      private
+
+      # Convert key to symbol
+      def symbolyze_key(key)
+        key.to_sym rescue key
+      end
+
+      # Recursive way of checking all hash
+      def map_value(key, value)
+        case value
+        when Array
+          value.map { |v| map_value(nil, v) }
+        when Hash
+          return custom_deep_symbolic_hash(value) unless is_a_custom_key?(key)
+          map_value(nil, array_from_mess(value))
+        else
+          value
+        end
+      end
+
+      def is_a_custom_key?(key)
+        HASH_OR_ARRAY_KEYS.include?(key)
+      end
+
+      # Since the custom keys come as an hash like: => { '1': { ... }, '2': { ... } }
+      # OR!
+      # A simple object from the root
+      # We need to unify the return value and return a simple array of objects
+      # Ugly? yup! as f*ck!
+      def array_from_mess(hash)
+        return key_contains_object?(hash.keys.first) ? [hash] : hash.values
+      end
+
+      def key_contains_object?(key)
+        (key.to_s =~ /[0-9]/) == nil
+      end
+    end
+  end
+end

data/lib/football_api/player.rb

@@ -0,0 +1,12 @@
+module FootballApi
+  class Player
+    attr_accessor :number, :name, :pos, :id
+
+    def initialize(hash = {})
+      @number = hash[:number]
+      @name   = hash[:name]
+      @pos    = hash[:pos]
+      @id     = hash[:id]
+    end
+  end
+end

data/lib/football_api/standing.rb

@@ -0,0 +1,104 @@
+module FootballApi
+  class Standing < FootballApi::BaseRequest
+    include FootballApi::Requestable
+
+    api_options action: :standings, action_params: :standing_params, json_key: :teams
+
+    class << self
+      attr_accessor :competition_id
+
+      def all_from_competition(competition)
+        self.competition_id = competition.is_a?(Competition) ? competition.id : competition
+
+        Array(response).map{ |standing| new(standing) }
+      end
+
+      def standing_params
+        { comp_id: self.competition_id }
+      end
+    end
+
+    # Response sample :
+    # [
+    #   {
+    #     "stand_id"=>"12049092",
+    #     "stand_competition_id"=>"1204",
+    #     "stand_season"=>"2014/2015",
+    #     "stand_round"=>"22",
+    #     "stand_stage_id"=>"12041081",
+    #     "stand_group"=>"",
+    #     "stand_country"=>"England",
+    #     "stand_team_id"=>"9092",
+    #     "stand_team_name"=>"Chelsea",
+    #     "stand_status"=>"same",
+    #     "stand_recent_form"=>"WWLDW",
+    #     "stand_position"=>"1",
+    #     "stand_overall_gp"=>"22",
+    #     "stand_overall_w"=>"16",
+    #     "stand_overall_d"=>"4",
+    #     "stand_overall_l"=>"2",
+    #     "stand_overall_gs"=>"51",
+    #     "stand_overall_ga"=>"19",
+    #     "stand_home_gp"=>"10",
+    #     "stand_home_w"=>"10",
+    #     "stand_home_d"=>"0",
+    #     "stand_home_l"=>"0",
+    #     "stand_home_gs"=>"24",
+    #     "stand_home_ga"=>"3",
+    #     "stand_away_gp"=>"12",
+    #     "stand_away_w"=>"10",
+    #     "stand_away_d"=>"0",
+    #     "stand_away_l"=>"0",
+    #     "stand_away_gs"=>"24",
+    #     "stand_away_ga"=>"3",
+    #     "stand_gd"=>"32",
+    #     "stand_points"=>"52",
+    #     "stand_desc"=>"Promotion - Champions League (Group Stage)"
+    #   }, ...
+    # ]
+
+    attr_accessor :stand_id, :stand_competition_id, :stand_season, :stand_round, :stand_stage_id,
+                  :stand_group, :stand_country, :stand_team_id, :stand_team_name, :stand_status,
+                  :stand_recent_form, :stand_position, :stand_overall_gp, :stand_overall_w,
+                  :stand_overall_d, :stand_overall_l, :stand_overall_gs, :stand_overall_ga,
+                  :stand_home_gp, :stand_home_w, :stand_home_d, :stand_home_l, :stand_home_gs,
+                  :stand_home_ga, :stand_away_gp, :stand_away_w, :stand_away_d, :stand_away_l,
+                  :stand_away_gs, :stand_away_ga, :stand_gd, :stand_points, :stand_desc
+
+    def initialize(hash = {})
+      @stand_id             = hash[:stand_id]
+      @stand_competition_id = hash[:stand_competition_id]
+      @stand_season         = hash[:stand_season]
+      @stand_round          = hash[:stand_round]
+      @stand_stage_id       = hash[:stand_stage_id]
+      @stand_group          = hash[:stand_group]
+      @stand_country        = hash[:stand_country]
+      @stand_team_id        = hash[:stand_team_id]
+      @stand_team_name      = hash[:stand_team_name]
+      @stand_status         = hash[:stand_status]
+      @stand_recent_form    = hash[:stand_recent_form]
+      @stand_position       = hash[:stand_position]
+      @stand_overall_gp     = hash[:stand_overall_gp]
+      @stand_overall_w      = hash[:stand_overall_w]
+      @stand_overall_d      = hash[:stand_overall_d]
+      @stand_overall_l      = hash[:stand_overall_l]
+      @stand_overall_gs     = hash[:stand_overall_gs]
+      @stand_overall_ga     = hash[:stand_overall_ga]
+      @stand_home_gp        = hash[:stand_home_gp]
+      @stand_home_w         = hash[:stand_home_w]
+      @stand_home_d         = hash[:stand_home_d]
+      @stand_home_l         = hash[:stand_home_l]
+      @stand_home_gs        = hash[:stand_home_gs]
+      @stand_home_ga        = hash[:stand_home_ga]
+      @stand_away_gp        = hash[:stand_away_gp]
+      @stand_away_w         = hash[:stand_away_w]
+      @stand_away_d         = hash[:stand_away_d]
+      @stand_away_l         = hash[:stand_away_l]
+      @stand_away_gs        = hash[:stand_away_gs]
+      @stand_away_ga        = hash[:stand_away_ga]
+      @stand_gd             = hash[:stand_gd]
+      @stand_points         = hash[:stand_points]
+      @stand_desc           = hash[:stand_desc]
+    end
+  end
+end

data/lib/football_api/version.rb

@@ -0,0 +1,3 @@
+module FootballApi
+  VERSION = "0.0.4"
+end

data/lib/football_api.rb

@@ -0,0 +1,32 @@
+require 'active_support'
+require 'active_support/core_ext/object'
+require 'active_support/core_ext/hash'
+require 'active_support/core_ext/numeric'
+require 'active_support/core_ext/string'
+require 'active_support/core_ext/time'
+require 'active_support/time_with_zone'
+require 'httparty'
+require 'football_api/mixins/requestable'
+require 'football_api/mixins/symbolizer'
+require 'football_api/base_request'
+require 'football_api/card'
+require 'football_api/comment'
+require 'football_api/commentary'
+require 'football_api/competition'
+require 'football_api/errors'
+require 'football_api/event'
+require 'football_api/fixture'
+require 'football_api/goal'
+require 'football_api/match'
+require 'football_api/match_info'
+require 'football_api/match_stats'
+require 'football_api/match_summary'
+require 'football_api/match_team'
+require 'football_api/player'
+require 'football_api/standing'
+require 'football_api/match_bench'
+require 'football_api/match_substitutions'
+require 'football_api/version'
+
+module FootballApi
+end

data/spec/commentary_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+RSpec.describe FootballApi::Commentary do
+  let(:match_id) { 1788007 }
+  let(:static_id) { 1755579 }
+  let(:default)  { JSONHelper::Commentaries.get(:default) }
+  let(:uri) {
+    "#{@base_url}/api/?APIKey=#{@api_key}&Action=commentaries&match_id=#{match_id}"
+  }
+
+  before(:each) do
+    stub_request(:get, uri)
+      .with(headers: @headers)
+      .to_return(status: 200, body: default.to_json)
+  end
+
+  let(:request_response) { FootballApi::Commentary.all_from_match(match_id) }
+
+  describe '.all_from_match' do
+    it 'sets match id' do
+      # doing a :static_id validation, this value must be set before request
+      # we can't request a match that we dont already have some information
+      # like :match_id and :match_static_id
+
+      expect(request_response).not_to be_nil
+      expect(request_response.static_id.to_i).to eq(static_id)
+    end
+
+    it 'sets all match summary cards' do
+      summary = request_response.match_summary
+
+      expect(summary).not_to be_nil
+      expect(summary.local_team_yellowcards.size).to eq(2)
+      expect(summary.local_team_redcards.size).to eq(0)
+      expect(summary.visitor_team_yellowcards.size).to eq(4)
+      expect(summary.visitor_team_redcards.size).to eq(0)
+    end
+
+    it 'sets all match summary goals' do
+      summary = request_response.match_summary
+
+      expect(summary).not_to be_nil
+      expect(summary.local_team_goals.size).to eq(1)
+      expect(summary.visitor_team_goals.size).to eq(2)
+    end
+
+    it 'sets local team and players' do
+      local_team = request_response.local_match_team
+
+      expect(local_team).not_to be_nil
+      expect(local_team.players.size).to eq(18)
+      expect(local_team.id).to eq(request_response.match_id)
+    end
+
+    it 'sets visitor team and players' do
+      visitor_team = request_response.visitor_match_team
+
+      expect(visitor_team).not_to be_nil
+      expect(visitor_team.players.size).to eq(18)
+      expect(visitor_team.id).to eq(request_response.match_id)
+    end
+
+    it 'sets match bench' do
+      match_bench = request_response.match_bench
+
+      expect(match_bench).not_to be_nil
+      expect(match_bench.match_id).to eq(request_response.match_id)
+    end
+
+    it 'sets local team bench' do
+      match_bench = request_response.match_bench
+
+      expect(match_bench.local_team).not_to be_nil
+      expect(match_bench.local_team.players.size).to eq(7)
+    end
+
+    it 'sets visitor team bench' do
+      match_bench = request_response.match_bench
+
+      expect(match_bench.visitor_team).not_to be_nil
+      expect(match_bench.visitor_team.players.size).to eq(7)
+    end
+
+    it 'sets match substitutions' do
+      match_substitutions = request_response.match_substitutions
+
+      expect(match_substitutions).not_to be_nil
+      expect(match_substitutions.match_id).to eq(request_response.match_substitutions.match_id)
+    end
+
+    it 'sets local team substitutions' do
+      match_substitutions = request_response.match_substitutions
+
+      expect(match_substitutions.local_team).not_to be_nil
+      expect(match_substitutions.local_team.size).to be(3)
+    end
+
+    it 'sets visitor team substitutions' do
+      match_substitutions = request_response.match_substitutions
+
+      expect(match_substitutions.visitor_team).not_to be_nil
+      expect(match_substitutions.visitor_team.size).to be(3)
+    end
+
+    it 'sets commentaries' do
+      commentaries = request_response.commentaries
+
+      expect(commentaries).not_to be_nil
+      expect(commentaries.size).to eq(111)
+    end
+  end
+end

data/spec/competition_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+RSpec.describe FootballApi::Competition do
+  let(:response)   { JSONHelper::Competitions.get(:all) }
+  let(:uri) { "#{@base_url}/api/?APIKey=#{@api_key}&Action=competitions" }
+
+  before(:each) do
+    stub_request(:get, uri)
+    .with(headers: @headers)
+    .to_return(status: 200, body: response.to_json)
+  end
+  let(:request_response) { FootballApi::Competition.all }
+
+  describe '.all' do
+    it 'not_fails' do
+      expect(request_response).not_to be_nil
+      expect(request_response.size).to eq(1)
+    end
+
+    it 'has_competition' do
+      competition = request_response.first
+
+      expect(competition).not_to be_nil
+      expect(competition.id).not_to be_nil
+    end
+  end
+end

data/spec/fixture_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+RSpec.describe FootballApi::Fixture do
+  let(:competition_id) { 1204 }
+
+  describe '.where from_to_date ' do
+    let(:response)   { JSONHelper::Fixtures.get(:from_to_date) }
+
+    let(:from_date) { '01.01.2015' }
+    let(:to_date) { '01.02.2015' }
+    let(:from_to_parameters) {
+      { :comp_id => competition_id, :from_date => from_date, :to_date => to_date }
+    }
+    let(:uri) {
+      "#{@base_url}/api/?APIKey=#{@api_key}&Action=fixtures"\
+      "&comp_id=#{competition_id}&from_date=#{from_date}&to_date=#{to_date}"
+    }
+
+    before(:each) do
+      stub_request(:get, uri)
+      .with(headers: @headers)
+      .to_return(status: 200, body: response.to_json)
+    end
+
+    let(:request_response) { FootballApi::Fixture.where(from_to_parameters) }
+
+    it 'not_fails' do
+      expect(request_response).not_to be_nil
+      expect(request_response.size).to eq(40)
+    end
+
+    it 'has_first_match' do
+      fixture = request_response.first
+      expect(fixture.match).not_to be_nil
+      expect(fixture.match.match_comp_id.to_i).to eq(competition_id)
+      expect(fixture.match_events.size).to eq(2)
+      expect(fixture.match_timer).to be_blank
+    end
+
+    it 'has_last_match' do
+      fixture = request_response.last
+      expect(fixture.match).not_to be_nil
+      expect(fixture.match.match_comp_id.to_i).to eq(competition_id)
+      expect(fixture.match_events.size).to eq(4)
+      expect(fixture.match_timer).to be_blank
+    end
+  end
+
+  describe '.where match_date ' do
+    let(:response)   { JSONHelper::Fixtures.get(:match_date) }
+
+    let(:match_date) { '01.01.2015' }
+    let(:date_parameters) {
+      { :comp_id => competition_id, :match_date => match_date }
+    }
+    let(:uri) {
+      "#{@base_url}/api/?APIKey=#{@api_key}&Action=fixtures"\
+      "&comp_id=#{competition_id}&match_date=#{match_date}"
+    }
+
+    before(:each) do
+      stub_request(:get, uri)
+      .with(headers: @headers)
+      .to_return(status: 200, body: response.to_json)
+    end
+
+    let(:request_response) { FootballApi::Fixture.where(date_parameters) }
+
+    it 'not_fails' do
+      expect(request_response).not_to be_nil
+      expect(request_response.size).to eq(10)
+    end
+
+    it 'has_first_match' do
+      fixture = request_response.first
+      expect(fixture.match).not_to be_nil
+      expect(fixture.match.match_comp_id.to_i).to eq(competition_id)
+      expect(fixture.match_events.size).to eq(2)
+      expect(fixture.match_timer).to be_blank
+    end
+
+    it 'has_last_match' do
+      fixture = request_response.last
+      expect(fixture.match).not_to be_nil
+      expect(fixture.match.match_comp_id.to_i).to eq(competition_id)
+      expect(fixture.match_events.size).to eq(12)
+      expect(fixture.match_timer).to be_blank
+    end
+  end
+end

data/spec/helpers/json_helper.rb

@@ -0,0 +1,41 @@
+# Automatically loads json files with an associated class for loading fixture
+module JSONHelper
+  class << self
+    # Uhuhuh! What a cache!
+    def cache
+      @cache ||= {}
+    end
+
+    def cache_or_load(path)
+      cache[path] ||= begin
+        file = File.read(path)
+        JSON.parse(file).symbolize_keys
+      end
+    end
+
+    def load_file(name)
+      path = File.expand_path("../../json/#{name}", __FILE__)
+      cache_or_load(path)
+    end
+  end
+
+  # TODO: Better way to deal with this.
+  # Declaring a class for each one was too much.
+  # With this, it works, but is too meta, I think.
+  class Generic
+    def self.get(name)
+      new.get(name)
+    end
+
+    def get(name)
+      file_name = "#{File.basename(self.class.name.underscore)}.json"
+      fixtures = ::JSONHelper.load_file(file_name)
+      fixtures[name.to_sym].clone
+    end
+  end
+
+  Dir[File.expand_path('../../json/*.json', __FILE__)].each do |file_name|
+    klass_name = "#{File.basename(file_name, '.json').camelize}"
+    JSONHelper.const_set(klass_name, Class.new(Generic))
+  end
+end