playwhe 0.1.0 → 0.2.0

data/lib/playwhe.rb

@@ -1,148 +1,91 @@
-require 'date'
-require 'net/http'
-
-require 'playwhe/version'
+require "date"
 
 module PlayWhe
-  # The day that Play Whe had its first draw; its start date
-  BIRTHDAY = Date.parse('4th July 1994')
+  # Play Whe's birthday, July 4th, 1994
+  BIRTHDAY = Date.new(1994, 7, 4)
+
+  # The date that Play Whe changed to having 3 draws per day
+  THREE_DRAWS_DATE = Date.new(2011, 11, 21) # November 21st, 2011
 
-  # The day that Play Whe changed to having 3 draws per day
-  THREE_DRAWS_DAY = Date.parse('21st November 2011')
+  # The date that Play Whe changed to having 4 draws per day
+  FOUR_DRAWS_DATE = Date.new(2015, 7, 6) # July 6th, 2015
 
-  HOST = 'nlcb.co.tt'
-  QUERY_PATH = 'search/pwq/countdateCash.php'
-  QUERY_URL  = URI("http://#{HOST}/#{QUERY_PATH}")
+  # The lowest Play Whe mark
+  LOWEST_MARK = 1
 
-  # the lowest and highest Play Whe marks
-  LOWEST_MARK  = 1
+  # The highest Play Whe mark
   HIGHEST_MARK = 36
 
-  # marks associated with their standard spirit
+  # The spirit name associated with each mark
   SPIRITS = {
-    1  => 'centipede',
-    2  => 'old lady',
-    3  => 'carriage',
-    4  => 'dead man',
-    5  => 'parson man',
-    6  => 'belly',
-    7  => 'hog',
-    8  => 'tiger',
-    9  => 'cattle',
-    10 => 'monkey',
-    11 => 'corbeau',
-    12 => 'king',
-    13 => 'crapaud',
-    14 => 'money',
-    15 => 'sick woman',
-    16 => 'jamette',
-    17 => 'pigeon',
-    18 => 'water boat',
-    19 => 'horse',
-    20 => 'dog',
-    21 => 'mouth',
-    22 => 'rat',
-    23 => 'house',
-    24 => 'queen',
-    25 => 'morocoy',
-    26 => 'fowl',
-    27 => 'little snake',
-    28 => 'red fish',
-    29 => 'opium man',
-    30 => 'house cat',
-    31 => 'parson wife',
-    32 => 'shrimps',
-    33 => 'spider',
-    34 => 'blind man',
-    35 => 'big snake',
-    36 => 'donkey'
+     1 => "centipede",
+     2 => "old lady",
+     3 => "carriage",
+     4 => "dead man",
+     5 => "parson man",
+     6 => "belly",
+     7 => "hog",
+     8 => "tiger",
+     9 => "cattle",
+    10 => "monkey",
+    11 => "corbeau",
+    12 => "king",
+    13 => "crapaud",
+    14 => "money",
+    15 => "sick woman",
+    16 => "jamette",
+    17 => "pigeon",
+    18 => "water boat",
+    19 => "horse",
+    20 => "dog",
+    21 => "mouth",
+    22 => "rat",
+    23 => "house",
+    24 => "queen",
+    25 => "morocoy",
+    26 => "fowl",
+    27 => "little snake",
+    28 => "red fish",
+    29 => "opium man",
+    30 => "house cat",
+    31 => "parson wife",
+    32 => "shrimps",
+    33 => "spider",
+    34 => "blind man",
+    35 => "big snake",
+    36 => "donkey"
   }
 
-  def self.results_for_month(year, month)
-    if date_in_range?(year, month)
-      params = { 'year'  => (year%100).to_s.rjust(2, '0'),
-                 'month' => Date::ABBR_MONTHNAMES[month] }
-
-      begin
-        response = Net::HTTP.post_form(QUERY_URL, params)
-      rescue
-        raise ServiceUnavailable
-      end
-
-      case response
-      when Net::HTTPOK
-        return parse_body(year, params['year'], month, params['month'], response.body)
-      else
-        raise ServiceUnavailable
-      end
-    else
-      # obviously we won't have any results
-      return []
-    end
-  end
-
-  def self.results_for_year(year, callbacks = {})
-    all_results = []
-
-    12.times do |m|
-      month = m + 1
-
-      skip = callbacks[:before] ? callbacks[:before].call(month) : false
+  # The short-hand names for the time of day Play Whe results are drawn,
+  # ordered by earliest to latest
+  PERIODS = %w(EM AM AN PM)
+
+  # The times of day, represented as seconds past midnight, that Play Whe
+  # results are drawn
+  DRAW_TIMES = {
+    "EM" => 10 * 3600,       # 10:00 AM
+    "AM" => 13 * 3600,       #  1:00 PM
+    "AN" => 16 * 3600,       #  4:00 PM
+    "PM" => 18 * 3600 + 1800 #  6:30 PM
+  }
 
-      unless skip
-        begin
-          flag = :ok
-          results = results_for_month(year, month)
-        rescue ServiceUnavailable
-          flag = :error
-          results = []
-        ensure
-          begin
-            continue = callbacks[:after] ? callbacks[:after].call(month, flag, results) : true
-          rescue
-            raise
-          ensure
-            all_results += results if results
-          end
-        end
+  class Error < StandardError; end
+  class NetworkError < Error; end
+  class BadResponseError < NetworkError
+    attr_reader :response
 
-        break unless continue
-      end
+    def initialize(response)
+      @response = response
+      super("status: #{response.status}, body: #{response.body}")
     end
-
-    all_results
-  end
-
-  class ServiceUnavailable < Exception
-  end
-
-private
-
-  def self.date_in_range?(year, month)
-    mday = year == BIRTHDAY.year && month == BIRTHDAY.month ? BIRTHDAY.day : 1
-    date = Date.new(year, month, mday)
-
-    date >= BIRTHDAY && date <= Date.today
-  end
-
-  def self.parse_body(year, yy, month, abbr_month, body)
-    # Here's the current form of the data on the page as of 27/05/2012:
-    #
-    # <date>: Draw # <draw> : <period>'s draw  was <mark>
-    #
-    # where
-    #
-    # <date>  : dd-Mmm-yy
-    # <draw>  : a positive integer
-    # <period>: Morning | Midday | Evening
-    # <mark>  : 1..36
-    results = body.scan(/(\d{2})-#{abbr_month}-#{yy}: Draw # (\d+) : (Morning|Midday|Evening)'s draw  was (\d+)/)
-
-    results.collect! do |r|
-      { draw: r[1].to_i,
-        date: Date.new(year, month, r[0].to_i),
-        period: {'Morning' => 1, 'Midday' => 2, 'Evening' => 3}[r[2]],
-        mark: r[3].to_i }
-    end.sort_by! { |r| r[:draw] }
   end
 end
+
+require_relative "playwhe/version"
+require_relative "playwhe/settings"
+require_relative "playwhe/util"
+require_relative "playwhe/http"
+require_relative "playwhe/fetcher"
+require_relative "playwhe/result"
+require_relative "playwhe/parser"
+require_relative "playwhe/get"

data/lib/playwhe/fetcher.rb

@@ -0,0 +1,25 @@
+module PlayWhe
+  class Fetcher
+    include Util
+
+    attr_reader :http_adapter, :url
+
+    def initialize(http_adapter, url)
+      @http_adapter = http_adapter
+      @url = url
+    end
+
+    def get(year:, month: nil)
+      y = normalize_year(year)
+      m = normalize_month(month)
+
+      response = http_adapter.post(url, year: y, month: m)
+
+      if response.ok?
+        response.body
+      else
+        raise BadResponseError, response
+      end
+    end
+  end
+end

data/lib/playwhe/get.rb

@@ -0,0 +1,214 @@
+require "date"
+require "ostruct"
+
+require "http"
+
+module PlayWhe
+  class << self
+    def get
+      @_get ||= Get.new(fetcher: fetcher, parser: Parser)
+    end
+
+    private
+
+    def fetcher
+      settings = Settings.config
+
+      http = ::HTTP.timeout :global,
+        read: settings.http.read_timeout,
+        write: settings.http.write_timeout,
+        connect: settings.http.connect_timeout
+
+      Fetcher.new(HTTP::Adapter.new(http), settings.url)
+    end
+  end
+
+  class Get
+    attr_reader :fetcher, :parser
+
+    def initialize(fetcher:, parser:)
+      @fetcher = fetcher
+      @parser = parser
+    end
+
+    VALID_ORDERS = %i(asc desc)
+
+    def results_for_year(date, order: :asc, skip_validation: false)
+      unless !!skip_validation
+        date = clean_and_validate_date(date)
+        order = clean_and_validate_order(order)
+      end
+
+      sort \
+        partition(
+          parse(fetcher.get(year: date.year)),
+          validation_context(date.year)
+        ),
+        order
+    end
+
+    def results_for_month(date, order: :asc, skip_validation: false)
+      unless !!skip_validation
+        date = clean_and_validate_date(date)
+        order = clean_and_validate_order(order)
+      end
+
+      sort \
+        partition(
+          parse(fetcher.get(year: date.year, month: date.month)),
+          validation_context(date.year, date.month)
+        ),
+        order
+    end
+
+    def results_for_day(date, order: :asc, skip_validation: false)
+      unless !!skip_validation
+        date = clean_and_validate_date(date)
+        order = clean_and_validate_order(order)
+      end
+
+      sort \
+        partition(
+          parse(fetcher.get(year: date.year, month: date.month)).select { |r|
+            r.date == date
+          }
+        ),
+        order
+    end
+
+    def most_recent(limit: nil, order: :desc, skip_validation: false)
+      unless !!skip_validation
+        limit = clean_and_validate_limit(limit)
+        order = clean_and_validate_order(order)
+      end
+
+      start_year = Date.today.year
+      end_year = BIRTHDAY.year
+      delta = -1
+
+      results_for_range(start_year, end_year, delta, limit, order)
+    end
+
+    def least_recent(limit: nil, order: :asc, skip_validation: false)
+      unless !!skip_validation
+        limit = clean_and_validate_limit(limit)
+        order = clean_and_validate_order(order)
+      end
+
+      start_year = BIRTHDAY.year
+      end_year = Date.today.year
+      delta = 1
+
+      results_for_range(start_year, end_year, delta, limit, order)
+    end
+
+    private
+
+    def results_for_range(start_year, end_year, delta, limit, order)
+      if limit.zero?
+        sort \
+          partition(
+            parse(fetcher.get(year: start_year)),
+            validation_context(start_year)
+          ),
+          order
+      else
+        year = start_year
+        all = []
+
+        while all.length < limit
+          all.concat(parse(fetcher.get(year: year)))
+          break if year == end_year
+          year += delta
+        end
+
+        all = sort_desc(all) if start_year > end_year
+        all = sort_asc(all) if start_year < end_year
+
+        sort \
+          partition(all[0, limit]),
+          order
+      end
+    end
+
+    def sort(partitioned_results, order)
+      [
+        send(:"sort_#{order}", partitioned_results.first),
+        partitioned_results.last
+      ]
+    end
+
+    def sort_asc(results)
+      default_date = Date.today
+      default_period_index = PERIODS.length
+      results.sort_by do |r|
+        [
+          r.date || default_date,
+          PERIODS.index(r.period) || default_period_index
+        ]
+      end
+    end
+
+    def sort_desc(results)
+      sort_asc(results).reverse
+    end
+
+    def partition(results, context = nil)
+      results.partition { |r| r.is_valid?(context) }
+    end
+
+    def parse(html_results)
+      parser.parse(html_results)
+    end
+
+    def validation_context(year, month = nil)
+      OpenStruct.new(year: year, month: month)
+    end
+
+    def clean_and_validate_date(date)
+      if date.nil?
+        raise ArgumentError, "date is required"
+      else
+        unless date.instance_of?(Date)
+          begin
+            date = Date.parse(date.to_s)
+          rescue ArgumentError
+            raise ArgumentError, "date must be a date"
+          end
+        end
+
+        if date < BIRTHDAY || date > Date.today
+          raise ArgumentError, "date must be between " \
+            "#{format_date(BIRTHDAY)} and " \
+            "#{format_date(Date.today)} inclusive"
+        end
+      end
+
+      date
+    end
+
+    def clean_and_validate_order(order)
+      order = order.to_s.to_sym
+
+      unless VALID_ORDERS.include?(order)
+        raise ArgumentError, "order must be one of #{VALID_ORDERS.join(', ')}"
+      end
+
+      order
+    end
+
+    def clean_and_validate_limit(limit)
+      limit = limit.to_i
+
+      if limit < 0
+        raise ArgumentError, "limit must be a non-negative integer"
+      end
+
+      limit
+    end
+
+    def format_date(date)
+      date.strftime("%Y-%m-%d")
+    end
+  end
+end