playwhe 0.1.0 → 0.2.0

data/lib/playwhe/http.rb

@@ -0,0 +1,39 @@
+require "http"
+
+module PlayWhe
+  module HTTP
+    class Response
+      attr_reader :response
+
+      def initialize(response)
+        @response = response
+      end
+
+      def status
+        response.status
+      end
+
+      def body
+        response.to_s
+      end
+
+      def ok?
+        status == 200
+      end
+    end
+
+    class Adapter
+      attr_reader :http_client
+
+      def initialize(http_client)
+        @http_client = http_client
+      end
+
+      def post(url, data)
+        Response.new http_client.post(url, form: data)
+      rescue ::HTTP::Error
+        raise PlayWhe::NetworkError
+      end
+    end
+  end
+end

data/lib/playwhe/parser.rb

@@ -0,0 +1,15 @@
+module PlayWhe
+  module Parser
+    PATTERN = /Draw #: <\/strong>(?<draw>\d+).*?Date: <\/strong>(?<day>\d{1,2})-(?<month>[A-Z]{3})-(?<year>\d{2}).*?Mark Drawn: <\/strong>(?<mark>\d+).*?Drawn at: <\/strong>(?<period>[A-Z]{2})/i
+
+    def self.parse(html_results)
+      html_results.to_enum(:scan, PATTERN).map do
+        m = $~
+        date = "#{m[:day]}-#{m[:month]}-#{m[:year]}"
+
+        Result.new \
+          draw: m[:draw], date: date, mark: m[:mark], period: m[:period]
+      end
+    end
+  end
+end

data/lib/playwhe/result.rb

@@ -0,0 +1,119 @@
+require "date"
+
+module PlayWhe
+  class Result
+    attr_reader :draw, :date, :mark, :period
+    attr_reader :errors
+
+    def initialize(draw:, date:, mark:, period:)
+      @draw = draw
+      @date = date
+      @mark = mark
+      @period = period
+      clean
+    end
+
+    def ==(other)
+      return true if other.equal?(self)
+      return false unless other.instance_of?(self.class)
+      draw == other.draw &&
+        date == other.date &&
+          mark == other.mark &&
+            period == other.period
+    end
+
+    def to_s
+      "#{draw},#{date ? date.strftime('%Y-%m-%d') : '-'},#{mark},#{period}"
+    end
+
+    def is_valid?(context = nil)
+      validate(context)
+      no_errors?
+    end
+
+    private
+
+    attr_reader :context
+
+    def clean
+      clean_draw
+      clean_date
+      clean_mark
+      clean_period
+    end
+
+    def clean_draw
+      @draw = draw.to_i
+    end
+
+    def clean_date
+      @date = Date.parse(date.to_s) unless date.is_a?(Date)
+    rescue ArgumentError
+      @date = nil
+    end
+
+    def clean_mark
+      @mark = mark.to_i
+    end
+
+    def clean_period
+      @period = period.to_s.upcase
+    end
+
+    def validate(context)
+      init(context)
+      validate_draw
+      validate_date
+      validate_mark
+      validate_period
+    end
+
+    def init(context)
+      @context = context
+      @errors = {}
+    end
+
+    def add_error(name, message)
+      @errors[name] ||= []
+      @errors[name] << message
+    end
+
+    def no_errors?
+      errors.empty?
+    end
+
+    def validate_draw
+      add_error(:draw, "must be a positive integer") unless draw >= 1
+    end
+
+    def validate_date
+      if date.nil?
+        add_error(:date, "must be a date")
+      else
+        if date < BIRTHDAY
+          add_error(:date, "must be greater than Play Whe's birthday")
+        end
+
+        if context && context.year && date.year != context.year
+          add_error(:date, "must be for the correct year (#{context.year})")
+        end
+
+        if context && context.month && date.month != context.month
+          add_error(:date, "must be for the correct month (#{context.month})")
+        end
+      end
+    end
+
+    def validate_mark
+      if mark < LOWEST_MARK || mark > HIGHEST_MARK
+        add_error(:mark, "must be between #{LOWEST_MARK} and #{HIGHEST_MARK} inclusive")
+      end
+    end
+
+    def validate_period
+      unless PERIODS.include?(period)
+        add_error(:period, "must be one of #{PERIODS.join(', ')}")
+      end
+    end
+  end
+end

data/lib/playwhe/settings.rb

@@ -0,0 +1,15 @@
+require "dry-configurable"
+
+module PlayWhe
+  class Settings
+    extend Dry::Configurable
+
+    setting :http do
+      setting :read_timeout, 5
+      setting :write_timeout, 5
+      setting :connect_timeout, 5
+    end
+
+    setting :url, "http://nlcb.co.tt/app/index.php/pwresults/playwhemonthsum"
+  end
+end

data/lib/playwhe/util.rb

@@ -0,0 +1,11 @@
+module PlayWhe::Util
+  module_function
+
+  def normalize_year(year)
+    "%02d" % (year.to_i % 100)
+  end
+
+  def normalize_month(month)
+    Date::ABBR_MONTHNAMES[month.to_i]
+  end
+end

data/lib/playwhe/version.rb

@@ -1,3 +1,3 @@
 module PlayWhe
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/playwhe.gemspec

@@ -1,25 +1,33 @@
-# -*- encoding: utf-8 -*-
-require File.expand_path('../lib/playwhe/version', __FILE__)
-
-Gem::Specification.new do |gem|
-  gem.authors       = ["Dwayne R. Crooks"]
-  gem.email         = ["me@dwaynecrooks.com"]
-  gem.description   = %q{A ruby gem for retrieving and storing Play Whe results.
-
-  The gem provides a ruby API and script for retrieving and storing Play Whe
-  results from the National Lotteries Control Board (NLCB) website at
-  http://www.nlcb.co.tt/.}
-  gem.summary       = %q{A ruby gem for retrieving and storing Play Whe results.}
-  gem.homepage      = "http://rubygems.org/gems/playwhe"
-
-  gem.add_dependency('data_mapper', '~> 1.2.0')
-  gem.add_dependency('dm-sqlite-adapter', '~> 1.2.0')
-  gem.add_dependency('trollop', '~> 1.16.2')
-
-  gem.files         = `git ls-files`.split($\)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.name          = "playwhe"
-  gem.require_paths = ["lib"]
-  gem.version       = PlayWhe::VERSION
+require_relative "lib/playwhe/version"
+
+Gem::Specification.new do |s|
+  s.author = "Dwayne Crooks"
+  s.email  = "dwayne@playwhesmarter.com"
+
+  s.description = <<-DESCRIPTION.strip.gsub(/\s+/, " ")
+    A Ruby library for retrieving Play Whe results from the
+    National Lotteries Control Board (NLCB) website.
+  DESCRIPTION
+
+  s.summary  = "Play Whe results should be easy to get"
+  s.homepage = "https://rubygems.org/gems/playwhe"
+  s.license  = "MIT"
+
+  s.executables = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.files       = `git ls-files`.split("\n")
+  s.test_files  = `git ls-files -- {test,spec,features}/*`.split("\n")
+
+  s.name          = "playwhe"
+  s.require_paths = ["lib"]
+  s.version       = PlayWhe::VERSION
+
+  s.required_ruby_version = ">= 2.0"
+
+  s.add_runtime_dependency "http", "~> 2.0", ">= 2.0.2"
+  s.add_runtime_dependency "dry-configurable", "~> 0"
+
+  s.add_development_dependency "bundler", "~> 1.0"
+  s.add_development_dependency "minitest", "~> 5.9"
+  s.add_development_dependency "pry-byebug", "~> 0"
+  s.add_development_dependency "rake", "~> 0"
 end

data/test/playwhe/fetcher_test.rb

@@ -0,0 +1,72 @@
+require "test_helper"
+
+describe PlayWhe::Fetcher do
+  let(:url) { "http://example.com" }
+  let(:year) { 2016 }
+  let(:month) { 1 }
+
+  describe "#get" do
+    it "makes a POST request" do
+      good_response = Object.new
+      def good_response.ok?
+        true
+      end
+      def good_response.body
+        ""
+      end
+
+      http_adapter = Minitest::Mock.new
+      http_adapter.expect \
+        :post, good_response, [url, { year: "16", month: "Jan" }]
+
+      fetcher = PlayWhe::Fetcher.new(http_adapter, url)
+      fetcher.get(year: year, month: month)
+
+      expect(http_adapter.verify).must_equal true
+    end
+
+    describe "when the response is good" do
+      it "returns the body of the response" do
+        http_adapter = Object.new
+        def http_adapter.post(*args)
+          good_response = Object.new
+          def good_response.ok?
+            true
+          end
+          def good_response.body
+            "results"
+          end
+          good_response
+        end
+
+        fetcher = PlayWhe::Fetcher.new(http_adapter, url)
+
+        expect(fetcher.get(year: year, month: month)).must_equal "results"
+      end
+    end
+
+    describe "when the response is bad" do
+      it "raises PlayWhe::BadResponseError" do
+        http_adapter = Object.new
+        def http_adapter.post(*args)
+          bad_response = Object.new
+          def bad_response.ok?
+            false
+          end
+          def bad_response.status
+            400
+          end
+          def bad_response.body
+            ""
+          end
+          bad_response
+        end
+
+        fetcher = PlayWhe::Fetcher.new(http_adapter, url)
+
+        expect { fetcher.get(year: year, month: month) }.must_raise \
+          PlayWhe::BadResponseError
+      end
+    end
+  end
+end

data/test/playwhe/get_test.rb

@@ -0,0 +1,187 @@
+require "test_helper"
+
+class FakeFetcher
+  def initialize(start_year, years: 1, days: 1)
+    @results = []
+
+    draw = 1
+    end_year = start_year + years - 1
+    (start_year..end_year).each do |year|
+      (1..12).each do |month|
+        (1..days).each do |day|
+          date = Date.new(year, month, day)
+
+          PlayWhe::PERIODS.each do |period|
+            @results << make_result(draw, date, period)
+            draw += 1
+          end
+
+          # One bad result per day
+          @results << make_result(draw, date, "XM")
+          draw += 1
+        end
+      end
+    end
+
+    @results.shuffle!
+  end
+
+  def get(year:, month: nil)
+    results.select do |r|
+      if month.nil?
+        r[:date].year == year
+      else
+        r[:date].year == year && r[:date].month == month
+      end
+    end
+    .map { |r| as_html(r) }
+    .join
+  end
+
+  private
+
+  attr_reader :results
+
+  def as_html(result)
+    draw = result[:draw]
+    date = result[:date].strftime("%d-%b-%y")
+    mark = result[:mark]
+    period = result[:period]
+
+    "<strong> Draw #: </strong>#{draw}<br><strong> Date: </strong>#{date}<br><strong> Mark Drawn: </strong>#{mark}<br><strong> Drawn at: </strong>#{period}"
+  end
+
+  def make_result(draw, date, period)
+    mark = (PlayWhe::LOWEST_MARK..PlayWhe::HIGHEST_MARK).to_a.shuffle.first
+    { draw: draw, date: date, mark: mark, period: period }
+  end
+end
+
+describe PlayWhe::Get do
+  let(:parser) { PlayWhe::Parser }
+
+  describe "#results_for_year" do
+    it "returns the results for the year of the given date in ascending order" do
+      fetcher = FakeFetcher.new(2014, years: 3) # 2014, 2015, 2016
+      get = PlayWhe::Get.new(fetcher: fetcher, parser: parser)
+
+      good_results, bad_results = get.results_for_year(Date.new(2015))
+
+      expect(good_results.length).must_equal(12 * 1 * 4)
+
+      expect(good_results.first.date).must_equal(Date.new(2015, 1, 1))
+      expect(good_results.first.period).must_equal("EM")
+
+      expect(good_results.last.date).must_equal(Date.new(2015, 12, 1))
+      expect(good_results.last.period).must_equal("PM")
+
+      expect(bad_results.length).must_equal(12 * 1)
+    end
+  end
+
+  describe "#results_for_month" do
+    it "returns the results for the year/month of the given date in ascending order" do
+      fetcher = FakeFetcher.new(2015, days: 10)
+      get = PlayWhe::Get.new(fetcher: fetcher, parser: parser)
+
+      good_results, bad_results = get.results_for_month(Date.new(2015, 4))
+
+      expect(good_results.length).must_equal(10 * 4)
+
+      expect(good_results.first.date).must_equal(Date.new(2015, 4, 1))
+      expect(good_results.first.period).must_equal("EM")
+
+      expect(good_results.last.date).must_equal(Date.new(2015, 4, 10))
+      expect(good_results.last.period).must_equal("PM")
+
+      expect(bad_results.length).must_equal(10)
+    end
+  end
+
+  describe "#results_for_day" do
+    it "returns the results for the year/month/day of the given date in ascending order" do
+      fetcher = FakeFetcher.new(2015, days: 10)
+      get = PlayWhe::Get.new(fetcher: fetcher, parser: parser)
+
+      good_results, bad_results = get.results_for_day(Date.new(2015, 10, 10))
+
+      expect(good_results.length).must_equal(4)
+
+      expect(good_results[0].date).must_equal(Date.new(2015, 10, 10))
+      expect(good_results[0].period).must_equal("EM")
+
+      expect(good_results[1].date).must_equal(Date.new(2015, 10, 10))
+      expect(good_results[1].period).must_equal("AM")
+
+      expect(good_results[2].date).must_equal(Date.new(2015, 10, 10))
+      expect(good_results[2].period).must_equal("AN")
+
+      expect(good_results[3].date).must_equal(Date.new(2015, 10, 10))
+      expect(good_results[3].period).must_equal("PM")
+
+      expect(bad_results.length).must_equal(1)
+    end
+  end
+
+  describe "#most_recent" do
+    describe "when limit is a positive integer" do
+      it "returns limit results in most recent to least recent order" do
+        fetcher = FakeFetcher.new(2015)
+        get = PlayWhe::Get.new(fetcher: fetcher, parser: parser)
+
+        good_results, bad_results = get.most_recent(limit: 6)
+
+        expect(good_results.length).must_equal(4)
+
+        expect(good_results[0].date).must_equal(Date.new(2015, 12, 1))
+        expect(good_results[0].period).must_equal("PM")
+
+        expect(good_results[1].date).must_equal(Date.new(2015, 12, 1))
+        expect(good_results[1].period).must_equal("AN")
+
+        expect(good_results[2].date).must_equal(Date.new(2015, 12, 1))
+        expect(good_results[2].period).must_equal("AM")
+
+        expect(good_results[3].date).must_equal(Date.new(2015, 12, 1))
+        expect(good_results[3].period).must_equal("EM")
+
+        expect(bad_results.length).must_equal(2)
+
+        expect(bad_results[0].date).must_equal(Date.new(2015, 12, 1))
+        expect(bad_results[1].date).must_equal(Date.new(2015, 11, 1))
+      end
+    end
+  end
+
+  describe "#least_recent" do
+    describe "when limit is a positive integer" do
+      it "returns limit results in least recent to most recent order" do
+        fetcher = FakeFetcher.new(2015)
+        get = PlayWhe::Get.new(fetcher: fetcher, parser: parser)
+
+        good_results, bad_results = get.least_recent(limit: 6)
+
+        expect(good_results.length).must_equal(5)
+
+        expect(good_results[0].date).must_equal(Date.new(2015, 1, 1))
+        expect(good_results[0].period).must_equal("EM")
+
+        expect(good_results[1].date).must_equal(Date.new(2015, 1, 1))
+        expect(good_results[1].period).must_equal("AM")
+
+        expect(good_results[2].date).must_equal(Date.new(2015, 1, 1))
+        expect(good_results[2].period).must_equal("AN")
+
+        expect(good_results[3].date).must_equal(Date.new(2015, 1, 1))
+        expect(good_results[3].period).must_equal("PM")
+
+        expect(good_results[4].date).must_equal(Date.new(2015, 2, 1))
+        expect(good_results[4].period).must_equal("EM")
+
+        expect(bad_results.length).must_equal(1)
+
+        expect(bad_results[0].date).must_equal(Date.new(2015, 1, 1))
+      end
+    end
+  end
+end