picturehouse_uk 3.0.14 → 5.0.0

data/lib/picturehouse_uk/cinema.rb

@@ -1,59 +1,43 @@
 module PicturehouseUk
   # The object representing a cinema on the Picturehouse UK website
-  class Cinema
+  class Cinema < Cinebase::Cinema
     # address css
-    ADDRESS_CSS = '.static-content #contact-us + p:first'
-    # cinema link css
-    CINEMA_LINKS_CSS = '.footer .col-sm-3 option + option'
-
-    # @return [String] the brand of the cinema
-    attr_reader :brand
-    # @return [String] the id of the cinema on the Picturehouse website
-    attr_reader :id
-    # @return [String] the name of the cinema
-    attr_reader :name
-    # @return [String] the slug of the cinema
-    attr_reader :slug
-    # @return [String] the url of the cinema on the Picturehouse website
-    attr_reader :url
-
-    # @param [Hash] options id, name and url of the cinemas
-    # @return [PicturehouseUk::Cinema]
-    def initialize(options)
-      @brand = 'Picturehouse'
-      @id    = options[:id]
-      @name  = options[:name]
-      @slug  = @name.downcase.gsub(/[^0-9a-z ]/, '').gsub(/\s+/, '-')
-      @url   = if options[:url][0] == '/'
-                 "http://www.picturehouses.com#{options[:url]}"
-               else
-                 options[:url]
-               end
-    end
+    ADDRESS_CSS = '.cinemaAdrass:not(.openingTime)'.freeze
+    # cinema link css on the /cinema page
+    CINEMA_LINKS_CSS = 'a[href*="/cinema/"]'.freeze
+
+    # @!attribute [r] id
+    #   @return [Integer] the numeric id of the cinema on the Cineworld website
+
+    # @!method initialize(options)
+    #   Constructor
+    #   @param [String] id the cinema id of the cinema in capitalized snake case
+    #   @return [PicturehouseUk::Cinema]
 
     # Return basic cinema information for all cinemas
     # @return [Array<PicturehouseUk::Cinema>]
     # @example
     #   PicturehouseUk::Cinema.all
-    #   # => [<PicturehouseUK::Cinema ...>, <PicturehouseUK::Cinema ...>, ...]
+    #   #=> [<PicturehouseUk::Cinema>, <PicturehouseUk::Cinema>, ...]
     def self.all
-      cinema_links.map { |link| new_from_link(link) }
+      cinema_hash.keys.map { |id| new(id) }
     end
 
-    # Find a single cinema
-    # @param [String] id the cinema id as used on the picturehouses.co.uk website
-    # @return [PicturehouseUk::Cinema, nil]
-    # @example
-    #   PicturehouseUk::Cinema.find('Dukes_At_Komedia')
-    #   # => <PicturehouseUK::Cinema ...>
-    def self.find(id)
-      all.find { |cinema| cinema.id == id }
+    # @api private
+    def self.cinema_hash
+      @cinema_hash ||= ListParser.new(cinema_links).to_hash
     end
 
+    # @!method address
+    #   Address of the cinema
+    #   @return [Hash] of different address parts
+    #   @see #adr
+
     # Address of the cinema
-    # @return [Hash] of different address parts
+    # @return [Hash] contains :street_address, :extended_address,
+    # :locality, :postal_code, :country
     # @example
-    #   cinema = PicturehouseUk::Cinema.find('Dukes_At_Komedia')
+    #   cinema = PicturehouseUk::Cinema.new('Dukes_At_Komedia')
     #   cinema.adr
     #   #=> {
     #         street_address:   '44-47 Gardner Street',
@@ -67,122 +51,163 @@ module PicturehouseUk
     def adr
       PicturehouseUk::Internal::Parser::Address.new(address_node.to_s).address
     end
-    alias_method :address, :adr
-
-    # The second address line of of the cinema
-    # @return [String, nil]
-    # @example
-    #   cinema = PicturehouseUk::Cinema.find('Dukes_At_Komedia')
-    #   cinema.extended_address
-    #   #=> 'North Laine'
-    # @note Uses method naming as at http://microformats.org/wiki/adr
-    def extended_address
-      address[:extended_address]
-    end
 
-    # Films with showings scheduled at this cinema
-    # @return [Array<PicturehouseUk::Film>]
+    # Brand of the cinema
+    # @return [String] which will always be 'Picturehouse'
     # @example
-    #   cinema = PicturehouseUk::Cinema.find('Dukes_At_Komedia')
-    #   cinema.films
-    #   # => [<PicturehouseUk::Film ...>, <PicturehouseUk::Film ...>, ...]
-    def films
-      PicturehouseUk::Film.at(@id)
-    end
+    #   cinema = PicturehouseUk::Cinema.new('Dukes_At_Komedia')
+    #   cinema.brand
+    #   #=> 'Picturehouse'
+    def brand
+      'Picturehouse'.freeze
+    end
+
+    # @!method country_name
+    #   Country of the cinema
+    #   @return [String] which will always be 'United Kingdom'
+    #   @example
+    #     cinema = PicturehouseUk::Cinema.new('Dukes_At_Komedia')
+    #     cinema.country_name
+    #     #=> 'United Kingdom'
+
+    # @!method extended_address
+    #   The second address line of the cinema
+    #   @return [String]
+    #   @example
+    #     cinema = PicturehouseUk::Cinema.new('Dukes_At_Komedia')
+    #     cinema.extended_address
+    #     #=> 'North Laine'
 
     # The name of the cinema (might include brand)
     # @return [String]
     # @example
-    #   cinema = PicturehouseUk::Cinema.find('Dukes_At_Komedia')
+    #   cinema = PicturehouseUk::Cinema.new('Dukes_At_Komedia')
     #   cinema.full_name
     #   #=> "Duke's At Komedia"
     def full_name
       name
     end
 
-    # The locality (town) of the cinema
-    # @return [String]
-    # @example
-    #   cinema = PicturehouseUk::Cinema.find('Dukes_At_Komedia')
-    #   cinema.locality
-    #   #=> 'Brighton'
-    # @note Uses the standard method naming as at http://microformats.org/wiki/adr
-    def locality
-      address[:locality]
-    end
+    # @!method locality
+    #   The locality (town) of the cinema
+    #   @return [String]
+    #   @example
+    #     cinema = PicturehouseUk::Cinema.new('Dukes_At_Komedia')
+    #     cinema.locality
+    #     #=> 'Brighton'
 
-    # Post code of the cinema
+    # The name of the cinema
     # @return [String]
     # @example
-    #   cinema = PicturehouseUk::Cinema.find('Dukes_At_Komedia')
-    #   cinema.postal_code
-    #   #=> 'BN1 1UN'
-    # @note Uses the standard method naming as at http://microformats.org/wiki/adr
-    def postal_code
-      address[:postal_code]
-    end
-
-    # The region (county) of the cinema
+    #   cinema = PicturehouseUk::Cinema.new('Dukes_At_Komedia')
+    #   cinema.name
+    #   #=> "Duke's At Komedia"
+    def name
+      self.class.cinema_hash.fetch(id, {})[:name]
+    end
+
+    # @!method postal_code
+    #   Post code of the cinema
+    #   @return [String]
+    #   @example
+    #     cinema = PicturehouseUk::Cinema.new('Dukes_At_Komedia')
+    #     cinema.postal_code
+    #     #=> 'BN1 1UN'
+
+    # @!method region
+    #   The region (county) of the cinema if provided
+    #   @return [String]
+    #   @example
+    #     cinema = PicturehouseUk::Cinema.new('Dukes_At_Komedia')
+    #     cinema.region
+    #     #=> 'East Sussex'
+
+    # @!method slug
+    #   The URL-able slug of the cinema
+    #   @return [String]
+    #   @example
+    #     cinema = PicturehouseUk::Cinema.new('Dukes_At_Komedia')
+    #     cinema.slug
+    #     #=> 'dukes-at-komedia'
+
+    # @!method street_address
+    #   The street address of the cinema
+    #   @return [String]
+    #   @example
+    #     cinema = PicturehouseUk::Cinema.new('Dukes_At_Komedia')
+    #     cinema.street_address
+    #     #=> '44-47 Gardner Street'
+
+    # The url of the cinema on the Picturehouse website
     # @return [String]
-    # @example
-    #   cinema = PicturehouseUk::Cinema.find('Dukes_At_Komedia')
-    #   cinema.region
-    #   #=> 'East Sussex'
-    # @note Uses the standard method naming as at http://microformats.org/wiki/adr
-    def region
-      address[:region]
-    end
-
-    # All planned screenings
-    # @return [Array<PicturehouseUk::Screening>]
-    # @example
-    #   cinema = PicturehouseUk::Cinema.find('Dukes_At_Komedia')
-    #   cinema.screenings
-    #   # => [<PicturehouseUk::Screening ...>, <PicturehouseUk::Screening ...>]
-    def screenings
-      PicturehouseUk::Screening.at(@id)
-    end
-
-    # The street adress of the cinema
-    # @return a String
-    # @example
-    #   cinema = PicturehouseUk::Cinema.find('Dukes_At_Komedia')
-    #   cinema.street_address
-    #   #=> '44-47 Gardner Street'
-    # @note Uses the standard method naming as at http://microformats.org/wiki/adr
-    def street_address
-      address[:street_address]
+    def url
+      "http://www.picturehouses.com#/cinema/#{id}"
     end
 
     private
 
     def self.cinema_links
-      home_doc.css(CINEMA_LINKS_CSS)
-    end
-
-    def self.home_doc
-      @home_doc ||= Nokogiri::HTML(website.home)
+      cinemas_doc.css(CINEMA_LINKS_CSS)
     end
+    private_class_method :cinema_links
 
-    def self.website
-      @website ||= PicturehouseUk::Internal::Website.new
-    end
-
-    def self.new_from_link(link)
-      url =  link.get_attribute('data-href')
-      name = link.children.first.to_s.split(' — ')[1]
-
-      new(id:   url.match(%r{/cinema/(.+)$})[1],
-          name: name,
-          url:  url)
+    def self.cinemas_doc
+      @cinemas_doc ||=
+        Nokogiri::HTML(PicturehouseUk::Internal::Website.new.cinemas)
     end
+    private_class_method :cinemas_doc
 
     def address_node
       @address_node ||= info_doc.css(ADDRESS_CSS)
     end
 
     def info_doc
-      @info_doc ||= Nokogiri::HTML(self.class.website.info(id))
+      @info_doc ||=
+        Nokogiri::HTML(PicturehouseUk::Internal::Website.new.information(id))
+    end
+
+    # @api private
+    # Utility class to parse the links from the cinemas page
+    class ListParser
+      def initialize(nodes)
+        @nodes = nodes
+      end
+
+      def to_hash
+        @nodes.each_with_object({}) do |node, result|
+          cinema_id = id(node)
+          cinema_name = name(node)
+          # Skip links that don't have valid cinema data
+          next unless cinema_id && cinema_name
+          # Skip duplicate entries
+          next if result.key?(cinema_id)
+
+          result[cinema_id] = { name: cinema_name, url: url(node) }
+        end
+      end
+
+      private
+
+      def id(node)
+        href = url(node)
+        return nil unless href
+        match = href.match(%r{/cinema/([^/?#]+)})
+        match ? match[1] : nil
+      end
+
+      def name(node)
+        # Cinema name is in a <p> tag within the link
+        p_tag = node.css('p').first
+        return nil unless p_tag
+        # Get text and remove the location span
+        p_tag.children.find { |child| child.text? }&.text&.strip
+      end
+
+      def url(node)
+        href = node.get_attribute('href')
+        # Convert relative URLs to absolute if needed
+        href&.start_with?('http') ? href : "https://www.picturehouses.com#{href}"
+      end
     end
   end
 end

data/lib/picturehouse_uk/internal/api.rb

@@ -0,0 +1,42 @@
+require 'net/http'
+require 'json'
+require 'openssl'
+
+module PicturehouseUk
+  # @api private
+  module Internal
+    # Fetches JSON data from the Picturehouse API
+    class Api
+      API_BASE = 'https://www.picturehouses.com'.freeze
+      API_ENDPOINT = '/api/get-movies-ajax'.freeze
+
+      # Fetch movie data for a cinema
+      # @param cinema_id [String] the cinema ID
+      # @param date [String] the date in YYYY-MM-DD format, or 'show_all_dates'
+      # @return [Hash] parsed JSON response
+      def get_movies(cinema_id, date = 'show_all_dates')
+        uri = URI("#{API_BASE}#{API_ENDPOINT}")
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+        request = Net::HTTP::Post.new(uri.path)
+        request.set_form_data(
+          'start_date' => date,
+          'cinema_id' => cinema_id,
+          'filters' => []
+        )
+
+        response = http.request(request)
+
+        return {} unless response.is_a?(Net::HTTPSuccess)
+
+        JSON.parse(response.body)
+      rescue StandardError => e
+        warn "Failed to fetch movies for cinema #{cinema_id}: #{e.message}"
+        {}
+      end
+    end
+  end
+end

data/lib/picturehouse_uk/internal/parser/address.rb

@@ -15,23 +15,50 @@ module PicturehouseUk
         # @note Uses the address naming from http://microformats.org/wiki/adr
         def address
           {
-            street_address:   array[1],
-            extended_address: array.length > 5 ? array[2] : nil,
+            street_address:   address_lines[0],
+            extended_address: extended_address,
             locality:         town,
-            region:           array[-2] == town ? nil : array[-2],
-            postal_code:      array[-1],
-            country:          'United Kingdom'
+            region:           region,
+            postal_code:      postal_code,
+            country_name:     'United Kingdom'.freeze
           }
         end
 
         private
 
-        def town
-          @town ||= array[0].to_s.split(', ')[-1]
+        def array
+          @array ||= begin
+            # Split on <br> tags first, then strip all HTML tags from each part
+            @html.split(/<br\s*\/?>/).map do |part|
+              # Strip all HTML tags and clean up whitespace
+              Nokogiri::HTML::DocumentFragment.parse(part).text.strip
+            end.reject(&:empty?)
+          end
         end
 
-        def array
-          @array ||= Array(@html.gsub(/\<.?p.?\>/, '').split('<br>'))
+        # Skip the first element (cinema name) and return address lines
+        def address_lines
+          @address_lines ||= array[1..-1] || []
+        end
+
+        def extended_address
+          address_lines.length > 4 ? address_lines[1] : nil
+        end
+
+        def postal_code
+          address_lines[-1]
+        end
+
+        def region
+          # If there are 4+ address lines (street, town, region, postcode),
+          # the region is at -2, otherwise nil
+          address_lines.length >= 4 ? address_lines[-2] : nil
+        end
+
+        def town
+          # Town is always the second-to-last item (before postcode)
+          # unless there's a region, then it's third-to-last
+          @town ||= address_lines.length >= 4 ? address_lines[-3] : address_lines[-2]
         end
       end
     end

data/lib/picturehouse_uk/internal/parser/screenings.rb

@@ -3,127 +3,121 @@ module PicturehouseUk
   module Internal
     # @api private
     module Parser
-      # Parses screenings page into an array of hashes for an individual cinema
-      Screenings = Struct.new(:cinema_id) do
-        # css for a day of films & screenings
-        LISTINGS = '.listings li:not(.dark)'
-        DATE = '.nav-collapse.collapse'
+      # Parses JSON API response into an array of screening hashes
+      class Screenings
+        def initialize(cinema_id)
+          @cinema_id = cinema_id
+        end
 
-        # parse the cinema page into an array of screenings attributes
+        # Parse the JSON response into an array of screening attributes
         # @return [Array<Hash>]
         def to_a
-          doc.css(LISTINGS).flat_map do |node|
-            FilmWithShowtimes.new(node, date_from_html(node.css(DATE).to_s)).to_a
-          end
+          return [] unless json_data['response'] == 'success'
+          return [] unless json_data['movies']
+
+          json_data['movies'].flat_map do |movie|
+            parse_movie(movie)
+          end.compact
         end
 
         private
 
-        def date_from_html(html)
-          if !!html.match(/listings-further-ahead-today/)
-            Date.now
-          else
-            html.match(/listings-further-ahead-(\d{4})(\d{2})(\d{2})/) do |m|
-              Date.new(m[1].to_i, m[2].to_i, m[3].to_i)
-            end
-          end
-        end
+        def parse_movie(movie)
+          return [] if movie['show_times'].nil? || movie['show_times'].empty?
 
-        def doc
-          @doc ||= Nokogiri::HTML(page)
+          movie['show_times'].map do |timing|
+            parse_timing(movie, timing)
+          end.compact
         end
 
-        def page
-          @page ||= PicturehouseUk::Internal::Website.new.whats_on(cinema_id)
+        def parse_timing(movie, timing)
+          # Skip sold out or unavailable screenings
+          return nil if timing['SoldoutStatus'] == 2
+          return nil unless timing['date_f'] && timing['time']
+
+          # Skip advance booking restrictions if not advertised
+          if movie['ABgtToday'] == true && movie['AdvertiseAdvanceBookingDate'] == false
+            return nil
+          end
+
+          {
+            film_name: sanitize_title(movie['Title']),
+            dimension: determine_dimension(movie['Title'], timing),
+            variant: extract_variants(timing),
+            booking_url: booking_url(timing),
+            starting_at: parse_datetime(timing['date_f'], timing['time'])
+          }
         end
-      end
-    end
 
-    FilmWithShowtimes = Struct.new(:node, :date) do
-      # film name css
-      NAME = '.top-mg-sm a'
-      # variants css
-      VARIANTS = '.film-times .col-xs-10'
+        def sanitize_title(title)
+          TitleSanitizer.new(title).sanitized
+        end
 
-      # The film name
-      # @return [String]
-      def name
-        TitleSanitizer.new(raw_name).sanitized
-      end
+        def determine_dimension(title, timing)
+          # Check title for 3D indicator
+          return '3d' if title =~ /3d/i
 
-      # Showings hashes
-      # @return [Array<Hash>]
-      def to_a
-        Array(node.css(VARIANTS)).flat_map do |variant|
-          Variant.new(variant, date).to_a.map do |hash|
-            {
-              film_name: name,
-              dimension: dimension
-            }.merge(hash)
+          # Check timing attributes for 3D
+          if timing['SessionAttributesNames']
+            return '3d' if timing['SessionAttributesNames'].any? { |attr| attr =~ /3d/i }
           end
+
+          '2d'
         end
-      end
 
-      private
+        def extract_variants(timing)
+          return [] unless timing['SessionAttributesNames']
 
-      def dimension
-        raw_name.match(/3d/i) ? '3d' : '2d'
-      end
+          variants = []
 
-      def raw_name
-        @raw_name ||= node.css(NAME).children.first.to_s
-      end
-    end
+          timing['SessionAttributesNames'].each do |attribute|
+            # Map known attributes to variant types
+            variants << 'baby' if attribute =~ /big scream/i
+            variants << 'imax' if attribute =~ /imax/i
+            variants << 'kids' if attribute =~ /kids|toddler/i
+            variants << 'arts' if attribute =~ /nt live|screen arts|rbo|roh|met opera/i
+            variants << 'senior' if attribute =~ /silver screen/i
+          end
 
-    # variants can have multiple screenings
-    Variant = Struct.new(:node, :date) do
-      SHOWTIMES  = '.btn'
-      VARIANT    = '.film-type-desc'
-      TRANSLATOR = {
-        'Big Scream'    => 'baby',
-        'IMAX'          => 'imax',
-        "Kids' Club"    => 'kids',
-        'NT Live'       => 'arts',
-        'Screen Arts'   => 'arts',
-        'Silver Screen' => 'senior'
-      }
-
-      # Variant arrays
-      # @return [Array<Hash>]
-      def to_a
-        node.css(SHOWTIMES).map do |node|
-          { variant: variant }.merge(Showtime.new(node, date).to_hash)
+          variants.uniq.sort
         end
-      end
-
-      private
 
-      def variant
-        @variant ||= TRANSLATOR.select do |k, _|
-          variant_text.include?(k)
-        end.values.uniq
-      end
+        def booking_url(timing)
+          return nil unless timing['SessionId']
 
-      def variant_text
-        @variant_text ||= node.css(VARIANT).to_s
-      end
-    end
+          # Vista booking URL format
+          "https://web.picturehouses.com/order/showtimes/#{@cinema_id}-#{timing['SessionId']}/seats"
+        end
 
-    # parse an individual screening node
-    Showtime = Struct.new(:node, :date) do
-      def to_hash
-        {
-          booking_url: node['href'],
-          time:        time
-        }
-      end
+        def parse_datetime(date_str, time_str)
+          # date_str format: "2024-10-30"
+          # time_str format: "19:30"
+          return nil unless date_str && time_str
+
+          date_parts = date_str.split('-').map(&:to_i)
+          time_parts = time_str.split(':').map(&:to_i)
+
+          # Create Time object in local timezone, then convert to UTC
+          Time.new(
+            date_parts[0], # year
+            date_parts[1], # month
+            date_parts[2], # day
+            time_parts[0], # hour
+            time_parts[1], # minute
+            0,             # second
+            '+00:00'       # UTC timezone
+          )
+        rescue StandardError => e
+          warn "Failed to parse datetime from #{date_str} #{time_str}: #{e.message}"
+          nil
+        end
 
-      private
+        def json_data
+          @json_data ||= api_client.get_movies(@cinema_id)
+        end
 
-      def time
-        @time ||= begin
-          hour, min = node.text.split('.').map(&:to_i)
-          date.to_time + (hour * 60 + min) * 60
+        def api_client
+          @api_client ||= Api.new
         end
       end
     end