odeon_uk 2.0.4 → 3.0.0

data/lib/odeon_uk/html/parser/film_with_screenings.rb

@@ -0,0 +1,160 @@
+module OdeonUk
+  # Internal utility classes: Do not use
+  # @api private
+  module Html
+    # Parses HTML with Nokogiri
+    module Parser
+      # Parses a chunk of HTML to derive movie showing data
+      class FilmWithScreenings
+        # CSS selector for a film title inside an individual film HTML
+        NAME_CSS      = '.presentation-info h4 a'
+        # CSS selector for a group of showtimes inside an individual film HTML
+        SHOWTIMES_CSS = '.times-all.accordion-group'
+
+        # @param [String] html a chunk of html
+        def initialize(html)
+          @html = html
+        end
+
+        # The film name
+        # @return [String]
+        def film_name
+          @film_name ||= Internal::TitleSanitizer.new(raw_film_name).sanitized
+        end
+
+        # array containing hashes of screening attributes
+        # @return [Array<Hash>]
+        def to_a
+          doc.css(SHOWTIMES_CSS).map do |node|
+            dimension_parser(node).to_a.map do |hash|
+              hash.merge(film_name: film_name)
+            end
+          end.flatten
+        end
+
+        private
+
+        def doc
+          @doc ||= Nokogiri::HTML(@html)
+        end
+
+        def raw_film_name
+          @raw_film_name ||= doc.css(NAME_CSS).children.first.to_s
+        end
+
+        def dimension_parser(node)
+          DimensionNodeParser.new(node)
+        end
+      end
+
+      # parses chunk of screenings for a particular screening dimension
+      class DimensionNodeParser
+        # CSS selector for a single screening inside a 'group of showtimes' HTML
+        SCREENING_CSS = '.show'
+        # CSS selector for showing technology for a 'group of showtimes' HTML
+        TECH_CSS = '.tech a'
+
+        # @param [Nokigiri::Node] node a Nokogiri node object
+        def initialize(node)
+          @node = node
+        end
+
+        # array containing hashes of screening attributes for dimension
+        # @return [Array<Hash>]
+        def to_a
+          screening_hashes.map do |hash|
+            hash.merge(dimension: dimension,
+                       variant:   add_imax(hash[:variant]))
+          end
+        end
+
+        private
+
+        def add_imax(original)
+          imax? ? "#{original} imax".strip : original
+        end
+
+        def dimension
+          dimension_from_tech || '2d'
+        end
+
+        def dimension_from_tech
+          tech.match(/[23]d/i) { |data| data[0] }
+        end
+
+        def imax?
+          !!tech.match(/imax/)
+        end
+
+        def screening_hashes
+          screening_nodes.map { |node| ScreeningNodeParser.new(node).to_hash }
+        end
+
+        def screening_nodes
+          @node.css(SCREENING_CSS)
+        end
+
+        def tech
+          @tech ||= @node.css(TECH_CSS).text.gsub('in ', '').downcase
+        end
+      end
+
+      # parses a single screening
+      class ScreeningNodeParser
+        # regex for time format
+        TIME_REGEX = %r(\d+/\d+/\d+ \d{2}\:\d{2})
+        # regex for D-Box screenings
+        DBOX_REGEX = /D-Box/
+
+        # @param [Nokigiri::Node] node a Nokogiri node object
+        def initialize(node)
+          @node = node
+        end
+
+        # hashes of screening attributes
+        # @return [Hash]
+        def to_hash
+          {
+            booking_url: booking_url,
+            time:        utc_time,
+            variant:     variant
+          }
+        end
+
+        private
+
+        def booking_url
+          link_attr('href').to_s
+        end
+
+        def link_attr(attribute)
+          @node.css('a').attribute(attribute)
+        end
+
+        def info
+          @node.css('i').to_s
+        end
+
+        def time
+          Time.parse(time_string)
+        end
+
+        def time_string
+          link_attr('title').to_s.match(TIME_REGEX).to_s + ' UTC'
+        end
+
+        def tz
+          @tz ||= TZInfo::Timezone.get('Europe/London')
+        end
+
+        def utc_time
+          tz.local_to_utc(time)
+        end
+
+        def variant
+          info.match(DBOX_REGEX) ? 'd-box' : ''
+        end
+      end
+    end
+  end
+end

data/lib/odeon_uk/html/screenings.rb

@@ -0,0 +1,38 @@
+module OdeonUk
+  # Internal utility classes: Do not use
+  # @api private
+  module Html
+    # The object representing a single screening of a film on the Odeon UK website
+    class Screenings
+      # css selector for film html chunks
+      FILM_CSS = '.film-detail'
+
+      # All currently listed films showing at a cinema
+      # @param [Integer] cinema_id id of the cinema on the website
+      # @return [Array<Hash>]
+      def self.at(cinema_id)
+        film_nodes(cinema_id).flat_map do |node|
+          screenings_parser(node).to_a
+        end
+      end
+
+      private
+
+      def self.screenings_parser(html)
+        Parser::FilmWithScreenings.new(html)
+      end
+
+      def self.film_nodes(id)
+        showtimes_doc(id).css(FILM_CSS).map { |node| node.to_s.gsub(/^\s+/, '') }
+      end
+
+      def self.showtimes(id)
+        OdeonUk::Html::Website.new.showtimes(id)
+      end
+
+      def self.showtimes_doc(id)
+        Nokogiri::HTML(showtimes(id))
+      end
+    end
+  end
+end

data/lib/odeon_uk/{internal → html}/website.rb

@@ -3,7 +3,7 @@ require 'open-uri'
 module OdeonUk
   # Internal utility classes: Do not use
   # @api private
-  module Internal
+  module Html
     # Utility class to make calls to the odeon website
     class Website
       # cinema page

data/lib/odeon_uk/internal/title_sanitizer.rb

@@ -13,6 +13,7 @@ module OdeonUk
         /\(live\)/i,                   # live in brackets
         'UKJFF -',                     # UK Jewish festival prefix
         /\bsing\-?a\-?long\b/i,        # singalong
+        'Autism Friendly - ',          # autism friendly
       ]
 
       # regexes and their replacements

data/lib/odeon_uk/screening.rb

@@ -5,6 +5,8 @@ module OdeonUk
     attr_reader :booking_url
     # @return [String] 2d or 3d
     attr_reader :dimension
+    # @return [String] the cinema id
+    attr_reader :cinema_id
     # @return [String] the cinema name
     attr_reader :cinema_name
     # @return [String] the film name
@@ -32,11 +34,9 @@ module OdeonUk
     # @param [Integer] cinema_id id of the cinema on the website
     # @return [Array<OdeonUk::Screening>]
     def self.at(cinema_id)
-      showtimes_page(cinema_id).to_a.map do |html|
-        screenings_parser(html).to_a.map do |attributes|
-          new(attributes.merge(cinema_hash(cinema_id)))
-        end
-      end.flatten
+      cinema = { cinema_id: cinema_id, cinema_name: Cinema.new(cinema_id).name }
+
+      parser.at(cinema_id).map { |hash| new(hash.merge(cinema)) }
     end
 
     # The date of the screening
@@ -60,16 +60,8 @@ module OdeonUk
 
     private
 
-    def self.screenings_parser(html)
-      OdeonUk::Internal::FilmWithScreeningsParser.new(html)
-    end
-
-    def self.showtimes_page(cinema_id)
-      OdeonUk::Internal::ShowtimesPage.new(cinema_id)
-    end
-
-    def self.cinema_hash(id)
-      { cinema_id: id, cinema_name: Cinema.find(id).name }
+    def self.parser
+      Html::Screenings
     end
   end
 end

data/lib/odeon_uk/version.rb

@@ -1,6 +1,6 @@
 # Ruby interface for http://www.odeon.co.uk
-# @version 2.0.4
+# @version 3.0.0
 module OdeonUk
   # Gem version
-  VERSION = '2.0.4'
+  VERSION = '3.0.0'
 end

data/lib/odeon_uk.rb

@@ -1,16 +1,23 @@
+require 'forwardable'
 require 'nokogiri'
 require 'tzinfo'
 require 'tzinfo/data'
 
 require_relative './odeon_uk/version'
+require_relative './odeon_uk/configuration'
 
-require_relative './odeon_uk/internal/film_with_screenings_parser'
-require_relative './odeon_uk/internal/showtimes_page'
 require_relative './odeon_uk/internal/title_sanitizer'
-require_relative './odeon_uk/internal/website'
+
+require_relative './odeon_uk/api/response'
+require_relative './odeon_uk/api/cinema'
+require_relative './odeon_uk/api/screenings'
+
+require_relative './odeon_uk/html/parser/film_with_screenings'
+require_relative './odeon_uk/html/website'
+require_relative './odeon_uk/html/cinema'
+require_relative './odeon_uk/html/screenings'
 
 require_relative './odeon_uk/cinema'
-require_relative './odeon_uk/film'
 require_relative './odeon_uk/screening'
 
 # odeon_uk gem

data/odeon_uk.gemspec

@@ -21,8 +21,10 @@ Gem::Specification.new do |gem|
   gem.version       = OdeonUk::VERSION
 
   gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'minitest-reporters'
   gem.add_development_dependency 'webmock'
 
+  gem.add_runtime_dependency 'CFPropertyList'
   gem.add_runtime_dependency 'nokogiri'
   gem.add_runtime_dependency 'tzinfo'
   gem.add_runtime_dependency 'tzinfo-data'

data/rake/fixture_creator.rb

@@ -0,0 +1,98 @@
+module FixtureCreator
+  class Api
+    def all_cinemas!
+      write_fixture(:all_cinemas)
+    end
+
+    def app_init!
+      write_fixture(:app_init)
+    end
+
+    def film_times!(cinema_id)
+      OdeonUk::Api::Screenings.send(:film_ids, cinema_id).each do |i|
+        write_film_times_fixture(cinema_id, i)
+      end
+    end
+
+    private
+
+    def fixture(name)
+      File.expand_path("../../test/fixtures/api/#{name}.plist", __FILE__)
+    end
+
+    def log(message)
+      puts "Create API fixture: #{message}"
+    end
+
+    def write_film_times_fixture(cinema_id, film_id)
+      FileUtils.mkdir_p 'film_times'
+      text = "film_times/#{cinema_id}-#{film_id}"
+      File.open(fixture(text), 'w+') do |file|
+        log(text)
+        file.write OdeonUk::Api::Response.new.send(:film_times_raw,
+                                                   cinema_id,
+                                                   film_id)
+      end
+    end
+
+    def write_fixture(kind)
+      FileUtils.mkdir_p kind.to_s
+      File.open(fixture(kind), 'w+') do |file|
+        log(kind)
+        file.write OdeonUk::Api::Response.new.send("#{kind}_raw".to_sym)
+      end
+    end
+  end
+
+  class Html < Struct.new(:cinema_id)
+    def cinema!
+      write_page_fixture(:cinema)
+    end
+
+    def film_node!(index)
+      write_node_fixture(index)
+    end
+
+    def showtimes!
+      write_page_fixture(:showtimes)
+    end
+
+    def sitemap!
+      write_page_fixture(:sitemap)
+    end
+
+    private
+
+    def fixture(name)
+      File.expand_path("../../test/fixtures/html/#{name}.html", __FILE__)
+    end
+
+    def log(message)
+      puts "Create HTML fixture: #{message}"
+    end
+
+    def write_node_fixture(index)
+      FileUtils.mkdir_p 'showtimes'
+      text = "showtimes/#{cinema_id}-#{index}"
+      File.open(fixture(text), 'w+') do |file|
+        log(text)
+        nodes = OdeonUk::Html::Screenings.send(:film_nodes, cinema_id)
+        node = if index.is_a?(Fixnum)
+          nodes[index]
+        else
+          nodes.select { |n| !!n.to_s.match(/#{index}/i) }[0]
+        end
+        file.write(node.to_s)
+      end
+    end
+
+    def write_page_fixture(kind)
+      FileUtils.mkdir_p kind.to_s
+      text = kind.to_s + (cinema_id ? "/#{cinema_id}" : '')
+      File.open(fixture(text), 'w+') do |file|
+        log(text)
+        file.write OdeonUk::Html::Website.new.send(*[kind, cinema_id].compact)
+      end
+    end
+  end
+end