football_api 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3de37e6a41a4af23643c980f5261a4e9d9345ec3
+  data.tar.gz: d2eb25bd2a80f95ef6c3e8a75649a854cfdd9560
+SHA512:
+  metadata.gz: 9f542c19784774e209a90c898ecf5ea44e95de8eb989df5d972e7ab71530554941eb5f90bd4143ee6c068d66dc68aa63c56a1e843ae4227776b89e40d0ba6a3e
+  data.tar.gz: 1e55fd1031075c1e7b4555576fc2d9c64bd24f1309101777237cd19a0676caa2c2cbbb361553c745abd451f599f5a9cd8127c52e4174ee2dff7eea585e46e9c8

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.env

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/.ruby-gemset

@@ -0,0 +1 @@
+football_api

data/.ruby-version

@@ -0,0 +1 @@
+2.2.0

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in football_api.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Afonso Tsukamoto
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,31 @@
+# FootballApi
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'football_api'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install football_api
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/football_api/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/football_api.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'football_api/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "football_api"
+  spec.version       = FootballApi::VERSION
+  spec.authors       = ["Afonso Tsukamoto"]
+  spec.email         = ["atsukamoto@faber-ventures.com"]
+  spec.summary       = %q{ Interface with football-api }
+  spec.description   = %q{ Interface with football-api }
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency 'reek', '~> 1.3', '>= 1.3.7'
+  spec.add_development_dependency 'rubocop', '~> 0.20', '>= 0.20.1'
+  spec.add_development_dependency 'pry', '~> 0.9', '>= 0.9.12'
+  spec.add_development_dependency 'pry-byebug', '~> 2.0.0'
+  spec.add_development_dependency 'rspec', '~> 3.2', '>= 3.2.0'
+  spec.add_development_dependency 'webmock', '~> 1.21', '>= 1.21.0'
+
+  spec.add_dependency 'dotenv', '~> 2.0.2'
+  spec.add_dependency 'activesupport', '~> 4.1'
+  spec.add_dependency 'httparty', '~> 0.13', '>= 0.13.0'
+  spec.add_dependency 'colored', '~> 1.2'
+  spec.add_dependency 'tzinfo', '~> 1.1', '>= 1.1.0'
+  spec.add_dependency 'eventmachine', '~> 1.0', '>= 1.0.3'
+end

data/lib/football_api/base_request.rb

@@ -0,0 +1,75 @@
+module FootballApi
+  class BaseRequest
+    include HTTParty
+    include FootballApi::Symbolizer
+
+    debug_output $stdout
+    # Disable the use of rails query string format.
+    #
+    # With rails query string format enabled:
+    #   => get '/', :query => { selected_ids: [1,2,3] }
+    #
+    # Would translate to this:
+    #   => /?selected_ids[]=1&selected_ids[]=2&selected_ids[]=3
+    #
+    disable_rails_query_string_format
+
+    # How many times should we retry the request if Timeout::Error is raised?
+    RETRIES = 3
+
+    # The API Base URI
+    base_uri 'http://football-api.com/'
+
+    # The default format of the requests. Used on HTTP header 'Content-Type'.
+    format :json
+
+    # The default params for every request
+    # TODO : Pass key in config
+    default_params 'APIKey' => '69216017-4bb7-96db-0deeadb1b645'
+
+    # Default request timeout in seconds. This can be overriden by module configuration.
+    default_timeout 15
+
+    class << self
+
+      # The generic get method for all requests.
+      # Uses httparty get and makes no assumptions about the response,
+      # simply returns it
+      def get!(options = {}, &block)
+        attempts ||= RETRIES
+        query = action_query(options)
+        get("/api/", query, &block)
+
+      rescue Timeout::Error => e
+        puts "Timeout! Retrying... (#{RETRIES - attempts})"
+
+        retry if (attempts -= 1) > 0
+
+        raise FootballApi::RequestError.new('Request timeout')
+      end
+
+      alias_method :request!, :get!
+
+      # This is an handy method for response parsing.
+      # Subclasses that include Requestable can simply use the json_key option
+      # and response will only contain that field.
+      # It also deep symbolizes the response keys
+      def response(options = {})
+        data = get!(options) || Hash.new
+
+        data = custom_deep_symbolic_hash(data)
+        data.present? ? data[json_id] : data
+      end
+
+      def action_query(options = {})
+        { query: { "Action" => action }.merge(options) }.tap do |hs|
+          hs[:query].merge!(get_parameters) if params_method
+        end
+      end
+
+      def get_parameters
+        send(params_method)
+      end
+    end
+  end
+end

data/lib/football_api/card.rb

@@ -0,0 +1,19 @@
+module FootballApi
+  class Card
+    TYPE = [ :yellow, :red ]
+
+    attr_accessor :type, :minute, :player
+
+    def initialize(hash = {})
+      return {} unless TYPE.include?(hash[:type])
+
+      @type = hash[:type]
+      @minute = hash[:minute]
+      @player = parse_player(hash)
+    end
+
+    def parse_player(hash = {})
+      FootballApi::Player.new(hash)
+    end
+  end
+end

data/lib/football_api/comment.rb

@@ -0,0 +1,13 @@
+module FootballApi
+  class Comment < FootballApi::BaseRequest
+    attr_accessor :id, :important, :is_goal, :minute, :comment
+
+    def initialize(hash = {})
+      @id        = hash[:id]
+      @important = hash[:important]
+      @is_goal   = hash[:isgoal]
+      @minute    = hash[:minute]
+      @comment   = hash[:comment]
+    end
+  end
+end

data/lib/football_api/commentary.rb

@@ -0,0 +1,79 @@
+module FootballApi
+  class Commentary < FootballApi::BaseRequest
+    include FootballApi::Requestable
+
+    api_options action: :commentaries, action_params: :commentary_params, json_key: :commentaries
+
+    class << self
+      attr_accessor :match_id
+
+      def all_from_match(match)
+        @match_id = match.is_a?(Match) ? match.id : match
+
+        res = response
+        res.map { |commentary| new(commentary) }.first
+      end
+
+      def commentary_params
+        { match_id: self.match_id }
+      end
+    end
+
+    attr_accessor :match_id, :static_id, :match_info, :match_summary,
+                  :match_stats, :local_match_team, :visitor_match_team,
+                  :commentaries, :match_bench, :match_substitutions
+
+    def initialize(hash = {})
+      @match_id            = hash[:comm_match_id]
+      @static_id           = hash[:comm_static_id]
+      @match_info          = parse_match_info(hash)
+      @match_summary       = parse_match_summary(hash)
+      @match_stats         = parse_match_stats(hash)
+      @local_match_team    = parse_match_teams(hash, :localteam)
+      @visitor_match_team  = parse_match_teams(hash, :visitorteam)
+      @match_bench         = parse_match_bench(hash)
+      @match_substitutions = parse_match_substitutions(hash)
+      @commentaries        = parse_comments(hash[:comm_commentaries])
+    end
+
+    def parse_match_info(hash = {})
+      hash = hash[:comm_match_info].merge(id: hash[:comm_match_id])
+      FootballApi::MatchInfo.new(hash)
+    end
+
+    def parse_match_summary(hash = {})
+      hash = hash[:comm_match_summary].merge(id: hash[:comm_match_id])
+      FootballApi::MatchSummary.new(hash)
+    end
+
+    def parse_match_stats(hash = {})
+      return unless hash[:comm_match_stats].is_a?(Hash)
+      hash = hash[:comm_match_stats].merge(id: hash[:comm_match_id])
+      FootballApi::MatchStats.new(hash)
+    end
+
+    def parse_match_teams(hash = {}, key)
+      FootballApi::MatchTeam.new(hash, key)
+    end
+
+    def parse_comments(hash = {})
+      return unless hash[:comment]
+
+      Array(hash[:comment]).map{ |comment| FootballApi::Comment.new(comment) }
+    end
+
+    def parse_match_bench(hash = {})
+      return unless hash[:comm_match_subs]
+
+      FootballApi::MatchBench.new(hash[:comm_match_subs]
+                                  .merge(match_id: hash[:comm_match_id]))
+    end
+
+    def parse_match_substitutions(hash)
+      return unless hash[:comm_match_substitutions]
+
+      FootballApi::MatchSubstitutions.new(hash[:comm_match_substitutions]
+                                          .merge(match_id: hash[:comm_match_id]))
+    end
+  end
+end

data/lib/football_api/competition.rb

@@ -0,0 +1,54 @@
+module FootballApi
+  class Competition < FootballApi::BaseRequest
+    include FootballApi::Requestable
+
+    api_options action: :competitions, json_key: :Competition
+
+    # Response sample :
+    # [
+    #   {
+    #     "id":"1064",
+    #     "name":"Superliga",
+    #     "region":"Albania"
+    #   } ...
+    # ]
+    attr_accessor :id, :name, :region
+
+    def self.all
+      response && response.map do |comp|
+        new(comp)
+      end
+    end
+
+    def self.where(options = {})
+      response.select{ |c| matches_options(c, options) }.map{ |hsh| new(hsh) }
+    end
+
+    def initialize(hash = {})
+      @id     = hash[:id]
+      @name   = hash[:name]
+      @region = hash[:region]
+    end
+
+    private
+
+    # Matches the two given hashes.
+    # For example, if an options hash has:
+    #     => {id:1, name: 'ze'}
+    #
+    # And the object has:
+    #     => {id:1, name: 'ze', region: 'beira'}
+    #
+    # This function returns the reduce(:&) from the array:
+    # [true, true, true] -> true
+    #
+    # Where the two first trues are from *id == id* and *name == name*
+    # and since the options hash has no key :region,
+    # it returns *true* since that's a non searched option
+    def matches_options(object, options)
+      options.keys.map{ |key|
+        object.has_key?(key) ? options[key] == object[key] : true
+      }.reduce(:&)
+    end
+  end
+end

data/lib/football_api/errors.rb

@@ -0,0 +1,13 @@
+module FootballApi
+  class BaseError < StandardError
+  end
+
+  class InvalidParameter < BaseError
+  end
+
+  class RequestError < BaseError
+  end
+
+  class InfostradaError < BaseError
+  end
+end

data/lib/football_api/event.rb

@@ -0,0 +1,19 @@
+module FootballApi
+  class Event
+    TYPES = %w(yellowcard goal redcard yellowred)
+
+    attr_accessor :event_id, :event_match_id, :event_type, :event_minute, :event_team,
+                  :event_player, :event_player_id, :event_result
+
+    def initialize(hash = {})
+      @event_id        = hash[:event_id]
+      @event_match_id  = hash[:event_match_id]
+      @event_type      = hash[:event_type]
+      @event_minute    = hash[:event_minute]
+      @event_team      = hash[:event_team]
+      @event_player    = hash[:event_player]
+      @event_player_id = hash[:event_player_id]
+      @event_result    = hash[:event_result]
+    end
+  end
+end

data/lib/football_api/fixture.rb

@@ -0,0 +1,44 @@
+module FootballApi
+  class Fixture < FootballApi::BaseRequest
+    include FootballApi::Requestable
+
+    api_options action: :fixtures, action_params: :fixture_params, json_key: :matches
+
+    class << self
+      attr_accessor :match_date, :from_date, :to_date, :comp_id
+
+      def where(options = {})
+        @comp_id = options.delete(:comp_id)
+        @match_date = options.delete(:match_date)
+        @from_date = options.delete(:from_date)
+        @to_date = options.delete(:to_date)
+
+        response.map{ |fixture|
+          new (fixture)
+        }
+      end
+
+      def fixture_params
+        [:comp_id, :match_date, :from_date, :to_date].each_with_object({}) do |symb, opts|
+          opts.merge!(symb => send(symb) ) if send(symb)
+        end
+      end
+    end
+
+    attr_accessor :match, :match_timer, :match_events
+
+    def initialize(hash = {})
+      @match                      = parse_match(hash)
+      @match_timer                = hash[:match_timer]
+      @match_events               = parse_match_events(hash[:match_events])
+    end
+
+    def parse_match(hash = {})
+      FootballApi::Match.new(hash)
+    end
+
+    def parse_match_events(arr = [])
+      Array(arr).map { |e| FootballApi::Event.new(e) }
+    end
+  end
+end

data/lib/football_api/goal.rb

@@ -0,0 +1,17 @@
+module FootballApi
+  class Goal
+    attr_accessor :score, :minute, :player, :owngoal, :penalty
+
+    def initialize(hash = {})
+      @score = hash[:score]
+      @minute = hash[:minute]
+      @owngoal = hash[:owngoal]
+      @penalty = hash[:penalty]
+      @player = parse_player(hash)
+    end
+
+    def parse_player(hash = {})
+      FootballApi::Player.new(hash)
+    end
+  end
+end

data/lib/football_api/match.rb

@@ -0,0 +1,59 @@
+module FootballApi
+  class Match < FootballApi::BaseRequest
+    include FootballApi::Requestable
+
+    api_options action: :today,
+                action_params: :match_params,
+                json_key: :matches
+
+    class << self
+      attr_accessor :competition_id
+
+      def all_from_competition(competition)
+        @competition_id = competition.is_a?(Competition) ? competition.id : competition
+
+        Array(response).map { |match| new(match) }
+      end
+
+      def match_params
+        { comp_id: self.competition_id}
+      end
+    end
+
+    attr_accessor :match_id, :static_id, :match_comp_id, :match_date,
+                  :match_formatted_date, :match_status, :match_time,
+                  :match_commentary_available, :match_ht_score,
+                  :match_localteam_id, :match_localteam_name,
+                  :match_localteam_score, :match_visitorteam_id,
+                  :match_visitorteam_name, :match_visitorteam_score,
+                  :match_venue_city_beta, :match_venue_id_beta,
+                  :match_venue_beta, :match_week_beta, :match_season_beta,
+                  :match_et_score, :match_ft_score
+
+
+    def initialize(hash = {})
+      @match_id                   = hash[:match_id]
+      @static_id                  = hash[:match_static_id]
+      @match_comp_id              = hash[:match_comp_id]
+      @match_date                 = hash[:match_date]
+      @match_formatted_date       = hash[:match_formatted_date]
+      @match_status               = hash[:match_status]
+      @match_time                 = hash[:match_time]
+      @match_commentary_available = hash[:match_commentary_available]
+      @match_localteam_id         = hash[:match_localteam_id]
+      @match_localteam_name       = hash[:match_localteam_name]
+      @match_localteam_score      = hash[:match_localteam_score]
+      @match_visitorteam_id       = hash[:match_visitorteam_id]
+      @match_visitorteam_name     = hash[:match_visitorteam_name]
+      @match_visitorteam_score    = hash[:match_visitorteam_score]
+      @match_ht_score             = hash[:match_ht_score]
+      @match_ft_score             = hash[:match_ft_score]
+      @match_et_score             = hash[:match_et_score]
+      @match_season_beta          = hash[:match_season_beta]
+      @match_week_beta            = hash[:match_week_beta]
+      @match_venue_beta           = hash[:match_venue_beta]
+      @match_venue_id_beta        = hash[:match_venue_id_beta]
+      @match_venue_city_beta      = hash[:match_venue_city_beta]
+    end
+  end
+end

data/lib/football_api/match_bench.rb

@@ -0,0 +1,27 @@
+module FootballApi
+  class MatchBench
+
+    attr_accessor :match_id, :local_team, :visitor_team
+
+    def initialize(hash = {})
+      @match_id     = hash[:match_id]
+      @local_team   = Bench.new(hash, :localteam)
+      @visitor_team = Bench.new(hash, :visitorteam)
+    end
+  end
+
+  class Bench
+
+    attr_accessor :team, :players
+
+    def initialize(opts = {}, key)
+      # XXX - Use case for more than one player, might be different
+      # Api returns single object without number index on single occurrence.
+      opts = opts[key]
+      return unless opts.present?
+
+      @team = key
+      @players = Array(opts[:player]).map { |v| Player.new(v) }
+    end
+  end
+end

data/lib/football_api/match_info.rb

@@ -0,0 +1,14 @@
+module FootballApi
+  class MatchInfo
+
+    attr_accessor :stadium_name, :attendance, :time, :referee, :id
+
+    def initialize(hash = {})
+      @id           = hash[:id]
+      @stadium_name = hash[:stadium][:name]    if hash[:stadium]
+      @attendance   = hash[:attendance][:name] if hash[:attendance]
+      @time         = hash[:time][:name]       if hash[:time]
+      @referee      = hash[:referee][:name]    if hash[:referee]
+    end
+  end
+end

data/lib/football_api/match_stats.rb

@@ -0,0 +1,29 @@
+module FootballApi
+  class MatchStats
+    attr_accessor :id, :local_team_stats, :visitor_team_stats
+
+    def initialize(hash = {})
+      @id             = hash[:id]
+      @local_team_stats = Stats.new(hash[:localteam])
+      @visitor_team_stats = Stats.new(hash[:visitorteam])
+    end
+  end
+
+
+  class Stats
+    attr_accessor :total_shots, :ongoal_shots, :fouls, :corners, :offsides, :possestiontime,
+                  :yellowcards, :redcards, :saves
+
+    def initialize(hash = {})
+      @total_shots    = hash[:shots][:total]          if hash[:shots]
+      @ongoal_shots   = hash[:shots][:ongoal]         if hash[:shots]
+      @fouls          = hash[:fouls][:total]          if hash[:fouls]
+      @corners        = hash[:corners][:total]        if hash[:corners]
+      @offsides       = hash[:offsides][:total]       if hash[:offsides]
+      @possestiontime = hash[:possestiontime][:total] if hash[:possestiontime]
+      @yellowcards    = hash[:yellowcards][:total]    if hash[:yellowcards]
+      @redcards       = hash[:redcards][:total]       if hash[:redcards]
+      @saves          = hash[:saves][:total]          if hash[:saves]
+    end
+  end
+end

data/lib/football_api/match_substitutions.rb

@@ -0,0 +1,27 @@
+module FootballApi
+  class MatchSubstitutions
+
+    attr_accessor :match_id, :local_team, :visitor_team
+
+    def initialize(hash = {})
+      @match_id     = hash[:match_id]
+      @local_team   = subs(hash, :localteam)
+      @visitor_team = subs(hash, :visitorteam)
+    end
+
+    def subs(hash, key)
+      return [] unless hash[key]
+      Array(hash[key][:substitution]).map { |s| Substitution.new(s) }
+    end
+  end
+
+  class Substitution
+    def initialize(opts = {})
+      @off    = opts[:off]
+      @on     = opts[:on]
+      @minute = opts[:minute]
+      @on_id  = opts[:on_id]
+      @off_id = opts[:off_id]
+    end
+  end
+end