f1results 0.6 → 3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 1b051ec7bbb7427df68b608f368ec9da378563ad
-  data.tar.gz: 7e0c83eaae83f0f033c0bd6137819b6d9f2e5fed
+SHA256:
+  metadata.gz: aa2c935bee2392688a8b77b2c56668778bb6b84525c3fb6ea4331d5520675d59
+  data.tar.gz: 0a035e5ce0d87d87dad070597b860cdb33e2a32cb77f0c48e5b5f9bf4968f8b8
 SHA512:
-  metadata.gz: 81e62187f6284f0a4449a31ca52e676b390e1dbb1ecbe946074f1020b139be6f628a2caee888582ec18ebb2ba0fb959ccbeff78a1adcd24a1c1565e76a046a32
-  data.tar.gz: b69492c988f8047988587a10097f0577ea3be5b8a19b6e3614249040f6917e3e092120361e97d848be6ffa0e2169153df71ff702d54d73882588e1e5ef0feb7d
+  metadata.gz: 7664c1698d0b058b1e7a2da0889e322869eac9fbc59c3589297690f843e5c4fcb38867b78448aa50aace0f9d73b32ec1415017f78f443d451497d98522c31235
+  data.tar.gz: d5deaedc384e08a0f02434cca1bd1e902c8b276b2bbf4d324ebc4b74ff44c1f51ab6709ea9e6df5ee3e5b1580052da5069b3eefd77ab4a6eea3f21683096a327

data/Rakefile

@@ -1,10 +1,58 @@
-require 'bundler/setup'
-require 'rake'
-require 'rake/testtask'
+require "bundler/setup"
+require "rake"
+require "rake/testtask"
+require "./test/lib/fixtures"
+require "open-uri"
+require "fileutils"
+require "tempfile"
 
 task default: :test
 
 Rake::TestTask.new do |t|
-  t.libs << 'test/lib'
-  t.pattern = 'test/*_test.rb'
+  t.libs << "test/lib"
+  t.pattern = "test/*_test.rb"
+  t.warning = false
 end
+
+def fixture_downloads
+  Fixtures::STUBS.flat_map do |_name, mappings|
+    mappings.filter_map do |path, fixture|
+      next if fixture.is_a?(Integer)
+
+      {
+        url: URI.join(F1Results::BASE_URL, path).to_s,
+        destination: File.join(Fixtures::FIXTURES_DIR, fixture)
+      }
+    end
+  end
+end
+
+namespace :fixtures do
+  desc "List fixture URLs and destinations without downloading them"
+  task :list do
+    fixture_downloads.each do |download|
+      puts "#{download[:url]} => #{download[:destination]}"
+    end
+  end
+
+  desc "Download fixtures from formula1.com"
+  task :download do
+    WebMock.disable!
+    FileUtils.mkdir_p(Fixtures::FIXTURES_DIR)
+
+    fixture_downloads.each do |download|
+      puts "Downloading #{download[:url]} => #{download[:destination]}"
+
+      Tempfile.create(["f1results-fixture-", ".html"], Fixtures::FIXTURES_DIR) do |temporary|
+        URI.open(download[:url]) do |remote_file|
+          IO.copy_stream(remote_file, temporary)
+        end
+        temporary.close
+        FileUtils.mv(temporary.path, download[:destination])
+      end
+    end
+  end
+end
+
+desc "Download fixtures from formula1.com (alias for fixtures:download)"
+task download_fixtures: "fixtures:download"

data/bin/f1results

@@ -3,54 +3,59 @@
 require 'rubygems'
 require 'optparse'
 require 'terminal-table'
-require File.expand_path('../../lib/f1results.rb', __FILE__)
+require_relative '../lib/f1results'
 
 year       = Time.now.year
-country    = ''
+grand_prix = ''
 event_type = :race
 url        = nil
 
 optparse = OptionParser.new do |opts|
-  opts.on('-y', '--year=YEAR', Integer)      { |val| year = val }
-  opts.on('-c', '--country=COUNTRY', String) { |val| country = val.downcase }
-  opts.on('-e', '--event=EVENT', String)     { |val| event_type = val.downcase.to_sym }
-  opts.on('-u', '--url=URL', String)         { |val| url = val }
+  opts.on('-y', '--year=YEAR', Integer)          { |val| year = val }
+  opts.on('-g', '--grandprix=GRANDPRIX', String) { |val| grand_prix = val.capitalize }
+  opts.on('-e', '--event=EVENT', String)         { |val| event_type = val.downcase.to_sym }
+  opts.on('-u', '--url=URL', String)             { |val| url = val }
   opts.parse!
 end
 
 begin
   event = if url.nil?
-    F1Results.fetch(year, country, event_type)
+    F1Results.fetch(year, grand_prix, event_type)
   else
     F1Results.fetch_with_url(url)
   end
-rescue
-  event_summary = url || "#{year} #{country} #{event_type}"
-  puts "No results for #{event_summary}"
+rescue RuntimeError => e
+  puts e
   exit
 end
 
-title = url.nil? ? "#{event.year} #{event.country_name} #{event.type_name}\n#{event.name}" : event.name
+title = url.nil? ? "#{event.year} #{event.grand_prix} #{event.type_name}\n#{event.name}" : event.name
 table = Terminal::Table.new title: title, rows: event.to_a
 
 if event.practice?
-  table.headings = %W(Pos Num Driver Team Time Gap Laps)
+  table.headings = %W(Pos No Driver Team Time Gap Laps)
   table.align_column 0, :right
   table.align_column 1, :right
   table.align_column 4, :right
+  table.align_column 5, :right
   table.align_column 6, :right
 
 elsif event.qualifying?
-  table.headings = %W(Pos Driver Team Q1 Q2 Q3 Laps)
+  table.headings = %W(Pos No Driver Team Q1 Q2 Q3 Laps)
   table.align_column 0, :right
+  table.align_column 1, :right
+  table.align_column 4, :right
+  table.align_column 5, :right
   table.align_column 6, :right
+  table.align_column 7, :right
 
 elsif event.race?
-  table.headings = %W(Pos Driver Country Team Time/Retired Points)
+  table.headings = %W(Pos No Driver Team Laps Time/Retired Points)
   table.align_column 0, :right
-  table.align_column 2, :center
+  table.align_column 1, :right
   table.align_column 4, :right
   table.align_column 5, :right
+  table.align_column 6, :right
 end
 
 puts table

data/lib/f1results/agent.rb

@@ -2,103 +2,134 @@ require 'mechanize'
 
 module F1Results
   class Agent < ::Mechanize
-    attr_accessor :event
-
-    def initialize(event = nil)
-      if event.nil?
-        @event = F1Results::Event.new
-      else
-        self.event = event
-      end
+    def initialize
       super
+      self.verify_mode = OpenSSL::SSL::VERIFY_NONE
     end
 
-    def fetch_results
-      return fetch_results_with_url(@default_url)
+    def get_url(event)
+      @event = event
+      return url
     end
 
-    def fetch_results_with_url(url)
-      begin
-        get(url)
-        @event.type = parse_event_type if @event.type.nil?
-        @event.country = parse_event_country if @event.country.nil?
-        @event.name = parse_event_title
-        @event.results = parse_event_results
-        return @event
-      rescue Mechanize::ResponseCodeError, Net::HTTPNotFound
-        raise "No results found at #{url}"
-      end
+    def get_results(new_event)
+      @event = new_event
+      event.url ||= url
+      update_event
+      return event
     end
 
-    def event=(event)
-      path = "content/fom-website/en/championship/results/#{event.year}-race-results/#{event.year}-#{event.country_slug}-results/#{event.type_slug}.html"
-      @default_url = ::File.join F1Results::BASEURL, path
-      @event = event
+    def get_results_with_url(new_url)
+      event.url = new_url
+      update_event
+      return event
     end
 
     private
 
-      def parse_event_type
-        return page.parser.xpath('//h1[@class="headline"]').text.strip rescue nil
+      def event
+        @event ||= Event.new
       end
 
-      def parse_event_country
-        return page.parser.xpath('//a[@class="tag-link"]').text.strip.parameterize rescue nil
-      end
+      def url
+        base_uri = URI.join F1Results::BASE_URL, "en/results/#{event.year}/"
+        year_uri = URI.join base_uri, 'races'
+        begin
+          get(year_uri)
+        rescue Mechanize::ResponseCodeError, Net::HTTPNotFound
+          raise "No results found for #{event.year}"
+        end
 
-      def parse_event_title
-        return page.parser.xpath('//a[contains(@class, "level-0")]').text rescue nil
-      end
+        grand_prix_nodes = page.parser.xpath("//table//tbody/tr/td[1]//a[contains(@href, '/races/')]").map do |a|
+          # Remove SVG icons from the links
+          a2 = a.dup
+          a2.search('.//svg').remove
+          a2
+        end
 
-      def parse_event_results
-        results = []
-        table = page.parser.xpath('//tbody')
+        grand_prix_node = grand_prix_nodes.find { |node| node.text.strip.downcase == event.grand_prix.downcase }
+        raise "No grand prix '#{event.grand_prix}' found for #{event.year}" if grand_prix_node.nil?
 
-        # Remove driver abbreviation from cell
-        table.xpath('//span[@class="tla"]').each(&:remove)
+        grand_prix_uri = URI.join base_uri, grand_prix_node.attr('href')
 
-        # Turn HTML table into an array of arrays
-        data = table.xpath('//tr').map do |row|
-          row.xpath('./td|./th').map do |cell|
-            cell = cell.text.gsub(/[[:space:]]+/, ' ').strip
-            cell.blank? ? nil : cell
-          end
+        begin
+          get(grand_prix_uri)
+        rescue Mechanize::ResponseCodeError, Net::HTTPNotFound
+          raise "Error fetching #{grand_prix_uri}"
         end
 
-        # Remove rows that have the cell "Q1 107% Time"
-        regex = /107%/
-        data.reject! { |row| row.any? { |cell| regex =~ cell } }
+        event_names = {
+          "race result" => :race_result_node,
+          "fastest laps" => :fastest_laps_node,
+          "pit stop summary" => :pit_stop_summary_node,
+          "starting grid" => :starting_grid_node,
+          "overall qualifying" => :overall_qualifying_node,
+          "qualifying" => :qualifying_node,
+          "practice 3" => :practice3_node,
+          "practice 2" => :practice2_node,
+          "practice 1" => :practice1_node,
+          "sprint" => :sprint_node,
+          "sprint grid" => :sprint_grid_node,
+          "sprint qualifying" => :sprint_qualifying_node
+        }
+
+        event_nodes = page.parser.xpath("//menu[@aria-labelledby='sidebar-dropdown']//li/a").map do |a|
+          # Remove SVG icons from the links
+          a2 = a.dup
+          a2.search('.//svg').remove
+          a2
+        end
 
-        header = parse_table_header(data.shift)
+        # Create a hash to store the nodes
+        nodes = {}
+        event_names.each do |name, key|
+          nodes[key] = event_nodes.find { |node| node.text.strip.downcase == name }
+        end
 
-        result_class = case
-        when @event.practice?
-          PracticeResult
-        when @event.qualifying?
-          QualifyingResult
+        # TODO: add support for Starting Grid, Warm Up, Pit Stop Summary, Fastest Laps
+        node = case
+        when event.race?
+          nodes[:race_result_node]
+        when event.qualifying?
+          nodes[:qualifying_node] || nodes[:overall_qualifying_node]
+        when event.practice3?
+          nodes[:practice3_node]
+        when event.practice2?
+          nodes[:practice2_node]
+        when event.practice1?
+          nodes[:practice1_node]
         else
-          RaceResult
+          raise "Unsupported event type '#{event.type}'"
         end
 
-        data.each_with_index do |row, i|
-          hash = Hash[header.zip(row)]
-          hash[:index] = i
+        raise "No results for event type '#{event.type}' at #{event.year} #{event.grand_prix}" if node.nil?
 
-          result = result_class.new(hash)
-          results << result
+        uri = URI.join base_uri, node.attr('href')
+        return uri.to_s
+      end
+
+      def update_event
+        begin
+          get(event.url)
+        rescue Mechanize::ResponseCodeError, Net::HTTPNotFound
+          raise "No results found at '#{url}'"
         end
 
-        return results
+        new_event = Parser.new(page).parse
+        event.type ||= new_event.type
+        validate_event(new_event)
+
+        event.grand_prix ||= new_event.grand_prix
+        event.circuit ||= new_event.circuit
+        event.name ||= new_event.name
+        event.results = new_event.results
       end
 
-      # Turn array of words to symbols
-      def parse_table_header(header)
-        header.map do |cell|
-          # Fix i18n cells that look like this
-          # {'Position' @ i18n}, {'Driver' @ i18n}, ...
-          cell = cell.match(/(')(.+)(')/)[2] if /i18n/ =~ cell
-          cell.to_s.strip.parameterize('_').to_sym
+      def validate_event(new_event)
+        if event.type != new_event.type
+          raise "Results at '#{url}' are returning from '#{new_event.type_name}', not the requested '#{event.type_name}'"
         end
       end
+
   end
 end

data/lib/f1results/event.rb

@@ -1,46 +1,40 @@
-require 'active_support/core_ext/string'
-
 module F1Results
   class Event
-    attr_accessor :year, :country, :type, :name, :results
-
-    TYPE_ALIASES = {
-      p1: :practice1,
-      p2: :practice2,
-      p3: :practice3,
-      q:  :qualifying,
-      r:  :race
-    }
+    attr_accessor :year, :grand_prix, :circuit, :type, :name, :results, :url
 
     def initialize(args = {})
       @results = []
       args.each { |k,v| send("#{k}=", v) }
     end
 
-    def country_name
-      @country.to_s.titleize
+    def grand_prix_slug
+      grand_prix.strip.downcase.gsub(/[:space:]+/, '-')
     end
 
-    def country_slug
-      @country.to_s.parameterize
+    # Human readable type, e.g. "Practice 1", "Qualifying", "Starting Grid"
+    def type_name
+      @type.to_s
+        .gsub(/\d/, ' \0')
+        .gsub('_', ' ')
+        .split(' ')
+        .map(&:capitalize)
+        .join(' ')
     end
 
-    def type=(type)
-      type = type.to_s.downcase.gsub(' ', '').to_sym
-      @type = TYPE_ALIASES[type] || type
+    def practice?
+      /^practice(1|2|3)$/ =~ @type.to_s
     end
 
-    # Human readable type, e.g. "Practice 1", "Qualifying"
-    def type_name
-      @type.to_s.gsub(/\d/, ' \0').capitalize
+    def practice1?
+      @type == :practice1
     end
 
-    def type_slug
-      type_name.parameterize
+    def practice2?
+      @type == :practice2
     end
 
-    def practice?
-      /^practice(1|2|3)$/ =~ @type.to_s
+    def practice3?
+      @type == :practice3
     end
 
     def qualifying?
@@ -55,21 +49,25 @@ module F1Results
       @results.map(&:to_a)
     end
 
-    def winner
-      @results.first.driver
+    def [](i)
+      @results[i]
+    end
+
+    def winning
+      self[0]
     end
 
-    def loser
-      @results.last.driver
+    def losing
+      self[-1]
     end
 
-    def fetch_results
-      agent = F1Results::Agent.new(self)
-      agent.fetch_results
+    def get_results
+      agent = F1Results::Agent.new
+      agent.get_results(self)
     end
 
-    def fetch_results_with_url(url)
-      agent = F1Results::Agent.new(self)
+    def get_results_with_url(url)
+      agent = F1Results::Agent.new
       agent.fetch_results_with_url(url)
     end
   end

data/lib/f1results/parser.rb

@@ -0,0 +1,95 @@
+module F1Results
+  class Parser
+    def initialize(page)
+      @page = page
+      @event = Event.new
+    end
+
+    def parse
+      @event.name = event_name
+      @event.type = event_type
+      @event.grand_prix = event_grand_prix
+      @event.circuit = event_circuit
+      @event.results = event_results
+      # TODO: date
+      return @event
+    end
+
+    private
+
+      def event_name
+        return @page.parser.at_xpath('//h1').text.gsub(/[[:space:]]+/, ' ').strip
+      end
+
+      def event_type
+        if m = @event.name.match(/(?:.+) - (.+)/)
+          result = m[1]
+            .gsub(/(?<=RACE )RESULT/i, '')
+            .gsub(/OVERALL(?= QUALIFYING)/i, '')
+            .gsub(/(?<=PRACTICE)( )(?=[1-3])/i, '')
+            .sub(/(?<=QUALIFYING)\s*\d+\z/i, '') # strip numbers for Qualifying
+            .strip
+            .downcase
+          result.to_sym
+        end
+      end
+
+      def event_grand_prix
+        node = @page.parser.at_xpath('(//dialog)[3]//a[.//title[text()="Active"]]')
+        node.xpath('.//svg').remove
+
+        return node.text.strip
+      end
+
+      def event_circuit
+        node = @page.parser.at_xpath('//h1/../../../../../div/following-sibling::div[1]//p[2]')
+        return node.text
+      end
+
+      def event_results
+        results = []
+        tbody = @page.parser.at_xpath('//tbody')
+
+        # Remove driver abbreviation from driver cell
+        tbody.xpath('.//span[@class="md:hidden"]').each(&:remove)
+
+        # Turn HTML tbody into an array of arrays
+        data = tbody.xpath('.//tr').map do |row|
+          row.xpath('./td|./th').map do |cell|
+            cell = cell.text.gsub(/[[:space:]]+/, ' ').strip
+            cell.empty? ? nil : cell
+          end
+        end
+
+        header = @page.parser.xpath('//thead//th').map do |cell|
+          cell.text.to_s
+            .gsub(/\./, '') # Pos. -> Pos
+            .gsub(/[[:space:]]+/, '')
+            .gsub(/\/.*/, '') # Time/Retired -> Time
+            .downcase
+            .to_sym
+        end
+
+        # Set result class type
+        result_class = case
+        when @event.practice?
+          PracticeResult
+        when @event.qualifying?
+          QualifyingResult
+        else
+          RaceResult
+        end
+
+        # Make each table row a Result
+        data.each_with_index do |row, i|
+          hash = Hash[header.zip(row)]
+          hash[:position] = i + 1
+
+          result = result_class.new(hash)
+          results << result
+        end
+
+        return results
+      end
+  end
+end

data/lib/f1results/result.rb

@@ -1,15 +1,10 @@
 module F1Results
   class Result
-    attr_accessor :index, :position, :driver, :driver_number, :driver_country_abbr, :team, :time, :gap, :laps
+    attr_accessor :position, :driver, :driver_number, :driver_country_abbr, :team, :time, :gap, :laps
+    attr_reader :position_name
 
-    alias :p=         :position=
-    alias :pos=       :position=
-    alias :name=      :driver=
-    alias :no=        :driver_number=
-    alias :country=   :driver_country_abbr=
-    alias :best_time= :time=
-    alias :race_time= :time=
-    alias :fastest=   :time=
+    alias_method :no=,  :driver_number=
+    alias_method :car=, :team=
 
     def initialize(args = {})
       args.each do |k, v|
@@ -18,16 +13,18 @@ module F1Results
       end
     end
 
-    def position=(n)
-      @position = case
+    def position_name=(n)
+      @position_name = case
       when n.to_s.empty?
         nil
       when n.to_i == 0
         n
       else
-        n.to_i
+        @position = n.to_i
       end
     end
+    alias_method :p=,   :position_name=
+    alias_method :pos=, :position_name=
 
     def driver_number
       @driver_number.to_i == 0 ? nil : @driver_number.to_i
@@ -38,35 +35,42 @@ module F1Results
     end
 
     def gap
+      # TODO: parse gap properly
       @gap.to_f == 0.0 ? nil : @gap.to_f
     end
   end
 
   class PracticeResult < Result
     def to_a
-      [position, driver_number, driver, team, time, gap, laps]
+      [position_name, driver_number, driver, team, time, gap, laps]
     end
+
+    # TODO: to_h, to_s
   end
 
   class QualifyingResult < Result
     attr_accessor :q1, :q2, :q3
 
     def to_a
-      [position, driver, team, q1, q2, q3, laps]
+      [position_name, driver_number, driver, team, q1, q2, q3, laps]
+    end
+
+    def q1
+      @time || @q1
     end
 
     def time
-      q3 || q2 || q1
+      @q3 || @q2 || @q1 || @time
     end
   end
 
   class RaceResult < Result
     attr_accessor :retired, :points
 
-    alias :points_awarded= :points=
+    alias_method :pts=, :points=
 
     def to_a
-      [position, driver, driver_country_abbr, team, time_or_retired, points]
+      [position_name, driver_number, driver, team, laps, time_or_retired, points]
     end
 
     def time_or_retired=(str)
@@ -76,6 +80,7 @@ module F1Results
         @retired = str
       end
     end
+    alias_method :time_retired=, :time_or_retired=
 
     def time_or_retired
       time || retired
@@ -85,4 +90,7 @@ module F1Results
       @points.to_i
     end
   end
+
+  # TODO: PitStop < Result
+  # TODO: FastestLap < Result
 end

data/lib/f1results/version.rb

@@ -1,3 +1,3 @@
 module F1Results
-  VERSION = '0.6'
+  VERSION = '3.0'
 end

data/lib/f1results.rb

@@ -1,12 +1,13 @@
-require 'f1results/version'
-require 'f1results/agent'
-require 'f1results/event'
-require 'f1results/result'
+require_relative './f1results/version'
+require_relative './f1results/agent'
+require_relative './f1results/parser'
+require_relative './f1results/event'
+require_relative './f1results/result'
 
 module F1Results
-  BASEURL = 'http://www.formula1.com'
+  BASE_URL = 'https://www.formula1.com/'
 
-  # Get results from formula1.com for a given year, country, and event type
+  # Get results from formula1.com for a given year, grand prix, and event type
   # (race or qualifying)
   #
   #   F1Results.f1results(2010, 'australia', :qualifying)
@@ -14,14 +15,14 @@ module F1Results
   # Returns an `F1Results::Event` object which has a method `results`, which
   # returns multiple objects of type `F1Results::Result`
 
-  def self.fetch(year, country, type = :race)
-    event = Event.new(year: year, country: country, type: type)
-    event.fetch_results
+  def self.fetch(year, grand_prix, type = :race)
+    event = Event.new(year: year, grand_prix: grand_prix, type: type)
+    event.get_results
     return event
   end
 
   def self.fetch_with_url(url)
     agent = Agent.new
-    return agent.fetch_results_with_url(url)
+    return agent.get_results_with_url(url)
   end
 end

data/test/agent_test.rb

@@ -1,74 +1,84 @@
 require 'test_helper'
 
-class AgentTest < MiniTest::Test
+class AgentTest < Minitest::Test
   include Fixtures
 
   def setup
+    stub_all
     @agent = F1Results::Agent.new
   end
 
-  def test_get_event_2015_australia_race
-    event = F1Results::Event.new(year: 2015, country: 'Australia', type: :race)
-    @agent.event = event
-    @agent.fetch_results
-    assert_equal '2015 FORMULA 1 ROLEX AUSTRALIAN GRAND PRIX', event.name
-    assert_equal 17, event.results.length
-    assert_equal 'Lewis Hamilton', event.winner
-    assert_equal 'Kevin Magnussen', event.loser
+  def test_get_url_2016_australia_practice1
+    event = F1Results::Event.new(year: 2016, grand_prix: 'Australia', type: :practice1)
+    url = 'https://www.formula1.com/en/results/2016/races/938/australia/practice/1'
+    assert_equal url, @agent.get_url(event)
   end
 
-  def test_get_event_2015_australia_qualifying
-    event = F1Results::Event.new(year: 2015, country: 'Australia', type: :qualifying)
-    @agent.event = event
-    @agent.fetch_results
-    assert_equal '2015 FORMULA 1 ROLEX AUSTRALIAN GRAND PRIX', event.name
-    assert_equal 20, event.results.length
-    assert_equal 'Lewis Hamilton', event.winner
-    assert_equal 'Roberto Merhi', event.loser
+  def test_get_url_2016_australia_qualifying
+    event = F1Results::Event.new(year: 2016, grand_prix: 'Australia', type: :qualifying)
+    url = 'https://www.formula1.com/en/results/2016/races/938/australia/qualifying'
+    assert_equal url, @agent.get_url(event)
   end
 
-  def test_get_event_2015_australia_practice1
-    event = F1Results::Event.new(year: 2015, country: 'Australia', type: :practice1)
-    @agent.event = event
-    @agent.fetch_results
-    assert_equal '2015 FORMULA 1 ROLEX AUSTRALIAN GRAND PRIX', event.name
-    assert_equal 16, event.results.length
-    assert_equal 'Nico Rosberg', event.winner
-    assert_equal 'Romain Grosjean', event.loser
+  def test_get_url_2016_australia_race
+    event = F1Results::Event.new(year: 2016, grand_prix: 'Australia', type: :race)
+    url = 'https://www.formula1.com/en/results/2016/races/938/australia/race-result'
+    assert_equal url, @agent.get_url(event)
   end
 
-  def test_get_event_2015_malaysia_practice2
-    event = F1Results::Event.new(year: 2015, country: 'Malaysia', type: :practice2)
-    @agent.event = event
-    @agent.fetch_results
-    assert_equal '2015 FORMULA 1 PETRONAS MALAYSIA GRAND PRIX', event.name
-    assert_equal 20, event.results.length
-    assert_equal 'Lewis Hamilton', event.winner
-    assert_equal 'Roberto Merhi', event.loser
+  def test_get_url_1984_brazil_qualifying
+    event = F1Results::Event.new(year: 1984, grand_prix: 'Brazil', type: :qualifying)
+    url = 'https://www.formula1.com/en/results/1984/races/466/brazil/qualifying/0'
+    assert_equal url, @agent.get_url(event)
   end
 
-  def test_fetch_results_2015_hungary_race
-    event = @agent.fetch_results_with_url('http://www.formula1.com/content/fom-website/en/championship/results/2015-race-results/2015-Hungary-results/race.html')
-    assert_equal 'FORMULA 1 PIRELLI MAGYAR NAGYDÍJ 2015', event.name
-    assert_equal 'hungary', event.country
-    assert event.race?
-    assert_equal 20, event.results.length
-    assert_equal 'Sebastian Vettel', event.winner
-    assert_equal 'Nico Hulkenberg', event.loser
+  def test_get_url_1984_brazil_race
+    event = F1Results::Event.new(year: 1984, grand_prix: 'Brazil', type: :race)
+    url = 'https://www.formula1.com/en/results/1984/races/466/brazil/race-result'
+    assert_equal url, @agent.get_url(event)
   end
 
-  def test_get_event_with_bad_year
-    assert_raises RuntimeError do
-      event = F1Results::Event.new(year: 1900, country: 'Australia', type: :race)
-      @agent.event = event
-      @agent.fetch_results
+  def test_get_url_1950_indianapolis_500_qualifying
+    event = F1Results::Event.new(year: 1950, grand_prix: 'Indianapolis', type: :qualifying)
+    url = 'https://www.formula1.com/en/results/1950/races/96/indianapolis/qualifying/0'
+    assert_equal url, @agent.get_url(event)
+  end
+
+  def test_get_url_1950_indianapolis_500_race
+    event = F1Results::Event.new(year: 1950, grand_prix: 'Indianapolis', type: :race)
+    url = 'https://www.formula1.com/en/results/1950/races/96/indianapolis/race-result'
+    assert_equal url, @agent.get_url(event)
+  end
+
+  def test_get_results_1950_indianapolis_500_race
+    event = F1Results::Event.new(year: 1950, grand_prix: 'Indianapolis', type: :race)
+    event = @agent.get_results(event)
+    assert_equal 36, event.results.length
+  end
+
+  def test_api
+    event = F1Results.fetch(1950, 'Indianapolis', :race)
+    assert_equal 36, event.results.length
+  end
+
+  def test_event_with_bad_year
+    assert_raise_with_message RuntimeError, "No grand prix 'Australia' found for 1900" do
+      event = F1Results::Event.new(year: 1900, grand_prix: 'Australia', type: :race)
+      @agent.get_url(event)
+    end
+  end
+
+  def test_event_with_bad_country
+    assert_raise_with_message RuntimeError, "No grand prix 'New Zealand' found for 2016" do
+      event = F1Results::Event.new(year: 2016, grand_prix: 'New Zealand', type: :race)
+      @agent.get_url(event)
     end
   end
 
-  def test_get_event_with_bad_grand_prix
-    assert_raises RuntimeError do
-      event = F1Results::Event.new(year: 2015, country: 'New Zealand', type: :race)
-      event.fetch_results
+  def test_event_with_bad_event_name
+    assert_raise_with_message RuntimeError, "Unsupported event type 'practice4'" do
+      event = F1Results::Event.new(year: 2016, grand_prix: 'Australia', type: :practice4)
+      @agent.get_url(event)
     end
   end
 end

data/test/event_test.rb

@@ -1,37 +1,31 @@
 require 'test_helper'
 
-class EventTest < MiniTest::Test
-  include Fixtures
-
+class EventTest < Minitest::Test
   def setup
     @event = F1Results::Event.new
   end
 
-  def test_type
-    @event.type = :qualifying
-    assert_equal 'qualifying', @event.type_slug
-    @event.type = :practice3
-    assert_equal 'practice-3', @event.type_slug
-    @event.type = :p3
-    assert_equal :practice3, @event.type
-  end
-
   def test_type_name
+    @event.type = :practice1
+    assert_equal 'Practice 1', @event.type_name
     @event.type = :practice3
     assert_equal 'Practice 3', @event.type_name
     @event.type = :qualifying
     assert_equal 'Qualifying', @event.type_name
     @event.type = :race
     assert_equal 'Race', @event.type_name
-  end
-
-  def test_type_setter_with_humanized_input
-    @event.type = 'Practice 3'
-    assert_equal :practice3, @event.type
-    @event.type = 'Qualifying'
-    assert_equal :qualifying, @event.type
-    @event.type = 'Race'
-    assert_equal :race, @event.type
+    @event.type = :starting_grid
+    assert_equal 'Starting Grid', @event.type_name
+    @event.type = :warm_up
+    assert_equal 'Warm Up', @event.type_name
+    @event.type = :pit_stop_summary
+    assert_equal 'Pit Stop Summary', @event.type_name
+    @event.type = :fastest_laps
+    assert_equal 'Fastest Laps', @event.type_name
+    @event.type = :sprint
+    assert_equal 'Sprint', @event.type_name
+    @event.type = :sprint_grid
+    assert_equal 'Sprint Grid', @event.type_name
   end
 
   def test_type_boolean_methods
@@ -49,11 +43,6 @@ class EventTest < MiniTest::Test
     refute @event.practice?
   end
 
-  def test_country_name
-    @event.country = 'great britain'
-    assert_equal 'Great Britain', @event.country_name
-  end
-
   def test_to_array
     @event.results << F1Results::RaceResult.new(position: 1, driver: 'Mark Webber', driver_country_abbr: 'AUS', team: 'Red Bull Racing-Renault', time: '1:25:11.288', points: 2)
     @event.results << F1Results::RaceResult.new(position: 2, driver: 'Fernando Alonso', driver_country_abbr: 'ESP', team: 'Ferrari', time: '+3.0 secs', points: 1)

data/test/parser_test.rb

@@ -0,0 +1,97 @@
+require 'test_helper'
+
+class ParserTest < Minitest::Test
+  include Fixtures
+
+  def test_2016_australia_practice1
+    event = events(:event_2016_australia_practice_1)
+    assert_equal '2016 FORMULA 1 ROLEX AUSTRALIAN GRAND PRIX - PRACTICE 1', event.name
+    assert_equal 'Australia', event.grand_prix
+    assert_equal 'Albert Park Grand Prix Circuit, Melbourne', event.circuit
+    assert_equal :practice1, event.type
+    assert_equal 22, event.results.length
+    assert_equal 'Lewis Hamilton', event.winning.driver
+    assert_equal 'Carlos Sainz', event.losing.driver
+  end
+
+  def test_2016_australia_qualifying
+    event = events(:event_2016_australia_qualifying)
+    assert_equal '2016 FORMULA 1 ROLEX AUSTRALIAN GRAND PRIX - QUALIFYING', event.name
+    assert_equal 'Australia', event.grand_prix
+    assert_equal 'Albert Park Grand Prix Circuit, Melbourne', event.circuit
+    assert_equal :qualifying, event.type
+    assert_equal 22, event.results.length
+
+    assert_equal 'Lewis Hamilton', event.winning.driver
+    assert_equal 'Pascal Wehrlein', event.losing.driver
+  end
+
+  def test_2016_australia_race
+    event = events(:event_2016_australia_race_result)
+    assert_equal '2016 FORMULA 1 ROLEX AUSTRALIAN GRAND PRIX - RACE RESULT', event.name
+    assert_equal 'Australia', event.grand_prix
+    assert_equal 'Albert Park Grand Prix Circuit, Melbourne', event.circuit
+    assert_equal :race, event.type
+    assert_equal 22, event.results.length
+    assert_equal 'Nico Rosberg', event.winning.driver
+    assert_equal 'Daniil Kvyat', event.losing.driver
+  end
+
+  def test_1984_brazil_qualifying
+    event = events(:event_1984_brazil_qualifying_0)
+    assert_equal 'BRAZILIAN GRAND PRIX 1984 - OVERALL QUALIFYING', event.name
+    assert_equal 'Brazil', event.grand_prix
+    assert_equal 'Autódromo Internacional do Rio de Janeiro, Brazil', event.circuit
+    assert_equal :qualifying, event.type
+    assert_equal 24, event.results.length
+    assert_equal 'Elio de Angelis', event.winning.driver
+    assert_equal 'Jonathan Palmer', event.losing.driver
+  end
+
+  def test_1984_brazil_race
+    event = events(:event_1984_brazil_race_result)
+    assert_equal 'BRAZILIAN GRAND PRIX 1984 - RACE RESULT', event.name
+    assert_equal 'Brazil', event.grand_prix
+    assert_equal 'Autódromo Internacional do Rio de Janeiro, Brazil', event.circuit
+    assert_equal :race, event.type
+    assert_equal 24, event.results.length
+    assert_equal 'Alain Prost', event.winning.driver
+    assert_equal 'Ayrton Senna', event.losing.driver
+  end
+
+  def test_1950_indianapolis_500_qualifying
+    event = events(:event_1950_indianapolis_qualifying_0)
+    assert_equal '1950 INDIANAPOLIS 500 - QUALIFYING', event.name
+    assert_equal 'Indianapolis', event.grand_prix
+    assert_equal 'Indianapolis Motor Speedway, United States', event.circuit
+    assert_equal :qualifying, event.type
+    assert_equal 1, event.results.length
+    assert_equal 'Walt Faulkner', event.winning.driver
+    assert_equal 'Walt Faulkner', event.losing.driver
+  end
+
+  def test_1950_indianapolis_500_race
+    event = events(:event_1950_indianapolis_race_result)
+    assert_equal '1950 INDIANAPOLIS 500 - RACE RESULT', event.name
+    assert_equal 'Indianapolis', event.grand_prix
+    assert_equal 'Indianapolis Motor Speedway, United States', event.circuit
+    assert_equal :race, event.type
+    # Note: 3 ties, so 36 finishers, 33 positions in this race
+    assert_equal 36, event.results.length
+    assert_equal 'Johnnie Parsons', event.winning.driver
+    assert_equal 'Duke Dinsmore', event.losing.driver
+  end
+
+  def test_2024_belgium_race
+    event = events(:event_2024_belgium_race_result)
+    assert_equal 'FORMULA 1 ROLEX BELGIAN GRAND PRIX 2024 - RACE RESULT', event.name
+    assert_equal 'Belgium', event.grand_prix
+    assert_equal 'Circuit de Spa-Francorchamps, Spa-Francorchamps', event.circuit
+    assert event.race?
+    assert_equal 20, event.results.length
+    # Note: George Russell won but was DQ'd, but still shows as first result
+    assert_equal 'George Russell', event.winning.driver
+    assert_equal 'DQ', event.results[0].position_name
+    assert_equal 'Zhou Guanyu', event.losing.driver
+  end
+end

data/test/result_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class ResultTest < MiniTest::Test
+class ResultTest < Minitest::Test
   def test_time
     result = F1Results::RaceResult.new
     result.time_or_retired = '1:25:11.288'
@@ -30,45 +30,49 @@ class ResultTest < MiniTest::Test
   end
 
   def test_parse_practice
-    result = F1Results::PracticeResult.new(position: '4', driver: 'Carlos Sainz', team: 'Toro Rosso', time: '1:31.014', laps:	'32')
-    assert_equal 4, result.position
-    assert_equal 'Carlos Sainz', result.driver
-    assert_equal 'Toro Rosso', result.team
-    assert_equal '1:31.014', result.time
-    assert_equal 32, result.laps
+    hash = { pos: '2', no: '26', driver: 'Daniil Kvyat', car: 'Red Bull Racing TAG Heuer', time: '1:30.146', gap: '+0.421s', laps: '14' }
+    result = F1Results::PracticeResult.new hash
+    assert_equal 2, result.position
+    assert_equal 'Daniil Kvyat', result.driver
+    assert_equal 'Red Bull Racing TAG Heuer', result.team
+    assert_equal '1:30.146', result.time
+    assert_equal 14, result.laps
   end
 
   def test_parse_qualifying
-    result = F1Results::QualifyingResult.new(position: '2', driver: 'Nico Rosberg', team: 'Mercedes', q1: '1:28.906', q2: '1:27.097', q3: '1:26.921', laps: '14')
-    assert_equal 2, result.position
-    assert_equal 'Nico Rosberg', result.driver
-    assert_equal 'Mercedes', result.team
-    assert_equal '1:28.906', result.q1
-    assert_equal '1:27.097', result.q2
-    assert_equal '1:26.921', result.q3
-    assert_equal 14, result.laps
+    hash = { pos: '8', no: '3', driver: 'Daniel Ricciardo', car: 'Red Bull Racing TAG Heuer', q1: '1:26.945', q2: '1:25.599', q3: '1:25.589', laps: '15' }
+    result = F1Results::QualifyingResult.new hash
+    assert_equal 8, result.position
+    assert_equal 'Daniel Ricciardo', result.driver
+    assert_equal 'Red Bull Racing TAG Heuer', result.team
+    assert_equal '1:26.945', result.q1
+    assert_equal '1:25.599', result.q2
+    assert_equal '1:25.589', result.q3
+    assert_equal 15, result.laps
   end
 
   def test_parse_race
-    result = F1Results::RaceResult.new(position: '3', driver: 'Sebastian Vettel', driver_country_abbr: 'GER', team: 'Ferrari', time: '+34.523s', points: '15')
+    hash = { pos: '3', no: '5', driver: 'Sebastian Vettel', car: 'Ferrari', laps: '57', time_retired: '+9.643s', pts: '15' }
+    result = F1Results::RaceResult.new hash
     assert_equal 3, result.position
     assert_equal 'Sebastian Vettel', result.driver
     assert_equal 'Ferrari', result.team
-    assert_equal '+34.523s', result.time
+    assert_equal '+9.643s', result.time
     assert_equal 15, result.points
   end
 
   def test_parse_qualifying_with_blank_values
     result = F1Results::QualifyingResult.new(position: '16', driver: 'Marcus Ericsson', team: 'Sauber', q1: '1:31.376', q2: nil, q3: nil, laps: 10)
     assert_equal '1:31.376', result.q1
-    assert_equal nil, result.q2
-    assert_equal nil, result.q3
+    assert_nil result.q2
+    assert_nil result.q3
     assert_equal 10, result.laps
   end
 
   def test_race_to_a
-    result = F1Results::RaceResult.new(position: '3', driver: 'Sebastian Vettel', driver_country_abbr: 'GER', team: 'Ferrari', time: '+34.523s', points: '15')
-    assert_equal [3, 'Sebastian Vettel', 'GER', 'Ferrari', '+34.523s', 15], result.to_a
+    hash = { pos: '3', no: '5', driver: 'Sebastian Vettel', car: 'Ferrari', laps: '57', time_retired: '+9.643s', pts: '15' }
+    result = F1Results::RaceResult.new hash
+    assert_equal [3, 5, 'Sebastian Vettel', 'Ferrari', 57, '+9.643s', 15], result.to_a
   end
 
   def test_unknown_key_doesnt_raise_error

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: f1results
 version: !ruby/object:Gem::Version
-  version: '0.6'
+  version: '3.0'
 platform: ruby
 authors:
 - Darren Jeacocke
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-18 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mechanize
@@ -16,84 +15,70 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.7'
+        version: '2.14'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.7'
+        version: '2.14'
 - !ruby/object:Gem::Dependency
   name: terminal-table
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4'
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.1'
+        version: '13.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.1'
+        version: '13.3'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.3'
+        version: '5.25'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.3'
+        version: '5.25'
 - !ruby/object:Gem::Dependency
   name: webmock
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.17'
+        version: 3.25.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.17'
+        version: 3.25.1
 description: Get F1 results from formula1.com
 email: dazonic@me.com
 executables:
@@ -108,16 +93,17 @@ files:
 - lib/f1results.rb
 - lib/f1results/agent.rb
 - lib/f1results/event.rb
+- lib/f1results/parser.rb
 - lib/f1results/result.rb
 - lib/f1results/version.rb
 - test/agent_test.rb
 - test/event_test.rb
+- test/parser_test.rb
 - test/result_test.rb
 homepage: https://github.com/daz/f1results
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -132,9 +118,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.5
-signing_key: 
+rubygems_version: 3.6.7
 specification_version: 4
 summary: F1 Results
 test_files: []