odeon_uk 3.0.6 → 4.0.0

data/.rdoc_options

@@ -1,16 +0,0 @@
---- !ruby/object:RDoc::Options
-encoding: UTF-8
-static_path: []
-rdoc_include:
-- .
-charset: UTF-8
-exclude: 
-hyperlink_all: false
-line_numbers: false
-main_page: 
-markup: tomdoc
-show_hash: false
-tab_width: 8
-title: 
-visibility: :protected
-webcvs: 

data/lib/odeon_uk/api/cinema.rb

@@ -1,67 +0,0 @@
-module OdeonUk
-  # Internal utility classes: Do not use
-  # @api private
-  module Api
-    # The object representing a cinema on the Odeon UK website
-    class Cinema
-      # @return [Integer] the numeric id of the cinema via the API
-      attr_reader :id
-
-      # @param [Integer, String] id cinema id
-      # @return [OdeonUk::Cinema]
-      def initialize(id)
-        @id = id.to_i
-      end
-
-      # Return basic cinema information for all cinemas
-      # @return [Array<OdeonUk::Cinema>]
-      def self.ids
-        cinemas_hash.keys.map(&:to_i)
-      end
-
-      # The locality (town) of the cinema
-      # @return [String]
-      def locality
-        cinema_hash['siteAddress2']
-      end
-
-      # The name of the cinema
-      # @return [String]
-      def name
-        cinema_hash['siteName']
-      end
-
-      # The url of the cinema
-      # @return [Nil]
-      def url
-        "http://www.odeon.co.uk/cinemas/#{urlized_name}/#{@id}/"
-      end
-
-      # Post code of the cinema
-      # @return [String]
-      def postal_code
-        cinema_hash['sitePostcode']
-      end
-
-      # The street adress of the cinema
-      # @return [String]
-      def street_address
-        cinema_hash['siteAddress1']
-      end
-
-      private
-
-      def self.cinemas_hash
-        @@cinemas_hash ||= Api::Response.new.all_cinemas['sites']
-      end
-
-      def cinema_hash
-        @cinema_hash ||= self.class.cinemas_hash[id.to_s]
-      end
-
-      def urlized_name
-        name.downcase.gsub(/[^a-z0-9]/, '_')
-      end
-    end
-  end
-end

data/lib/odeon_uk/api/screenings.rb

@@ -1,103 +0,0 @@
-module OdeonUk
-  # Internal utility classes: Do not use
-  # @api private
-  module Api
-    # The object representing a single screening of a film via the Odeon UK api
-    class Screenings
-      # All currently listed screenings at a cinema
-      # @param [Integer] cinema_id id of the cinema
-      # @return [Array<Hash>]
-      def self.at(cinema_id)
-        film_ids(cinema_id).flat_map do |film_id|
-          times_response = response.film_times(cinema_id, film_id)
-
-          times_response.flat_map do |day|
-            date =         day['date']
-            screenings =   day['attributes']
-
-            screenings.flat_map do |screening|
-              performances = screening['showtimes']
-
-              performances.flat_map do |p|
-                {
-                  dimension: screening['attribute'].include?('3D') ? '3d' : '2d',
-                  film_name: films_map(cinema_id)[film_id],
-                  time:      TimeParser.new(date, p[0]['performanceTime']).to_utc,
-                  variant:   VariantParser.new(screening['attribute']).to_a
-                }
-              end
-            end
-          end
-        end
-      end
-
-      private
-
-      def self.app_init
-        @@app_init ||= Response.new.app_init
-      end
-
-      def self.film_ids(cinema_id)
-        films_map(cinema_id).keys
-      end
-
-      def self.films_map(cinema_id)
-        films_at(cinema_id).each_with_object({}) do |f, result|
-          result[f['filmMasterId']] = f['title']
-        end
-      end
-
-      def self.films_at(cinema_id)
-        app_init['films'].select { |f| f['sites'].include?(cinema_id) }
-      end
-
-      def self.response
-        @@response ||= Response.new
-      end
-    end
-
-    TimeParser = Struct.new(:date, :time) do
-      def to_utc
-        tz.local_to_utc(parsed_time)
-      end
-
-      private
-
-      def early_morning_screening?
-        !!time.match(/\A0/)
-      end
-
-      def parsed_date
-        case date
-        when 'Today'    then Time.now.strftime '%Y-%m-%d'
-        when 'Tomorrow' then (Time.now + 60 * 60 * 24).strftime '%Y-%m-%d'
-        else date.gsub('.', '').match(/\d+\s\w+\z/)[0]
-        end
-      end
-
-      def parsed_time
-        parsed_time = Time.parse("#{parsed_date} #{time} UTC")
-        # Odeon deliberately mislabel their 00:01 screenings as the day before
-        early_morning_screening? ? parsed_time + 60 * 60 * 24 : parsed_time
-      end
-
-      def tz
-        @tz ||= TZInfo::Timezone.get('Europe/London')
-      end
-    end
-
-    VariantParser = Struct.new(:text) do
-      TRANSLATOR = {
-        'Culture'       => 'arts',
-        'Kids'          => 'kids',
-        'IMAX'          => 'imax',
-        'Newbies'       => 'baby',
-        'Silver Cinema' => 'senior'
-      }
-
-      def to_a
-        TRANSLATOR.select { |k, _| text.include?(k) }.values.uniq
-      end
-    end
-  end
-end

data/lib/odeon_uk/configuration.rb

@@ -1,21 +0,0 @@
-module OdeonUk
-  class << self
-    attr_accessor :configuration
-  end
-
-  def self.configuration
-    @configuration ||= Configuration.new
-  end
-
-  def self.configure
-    yield(configuration)
-  end
-
-  class Configuration
-    attr_accessor :method
-
-    def initialize
-      @method = :html
-    end
-  end
-end

data/lib/odeon_uk/html/cinema.rb

@@ -1,101 +0,0 @@
-module OdeonUk
-  # Internal utility classes: Do not use
-  # @api private
-  module Html
-    # The object representing a cinema on the Odeon UK website
-    class Cinema
-      ADDRESS_REGEX = '.gethere .span4 .description'
-      ALL_LINKS =     '.sitemap a[href*=cinemas]'
-
-      # @return [Integer] the numeric id of the cinema on the Odeon website
-      attr_reader :id
-
-      # @param [Integer, String] id cinema id
-      # @return [OdeonUk::Cinema]
-      def initialize(id)
-        @id = id.to_i
-      end
-
-      # Return basic cinema information for all cinemas
-      # @return [Array<OdeonUk::Cinema>]
-      def self.ids
-        cinema_links.map { |link| id_from(link) }
-      end
-
-      # The locality (town) of the cinema
-      # @return [String]
-      def locality
-        return unless address_node
-        address_node.text.match(/\w+(\s\w+){0,}\s+(\w+(\s\w+){0,})/)[2]
-      end
-
-      # The name of the cinema
-      # @return [String]
-      def name
-        cinema_link_doc.children.first.to_s
-      end
-
-      # The web url of the cinema
-      # @return [String]
-      def url
-        @url ||= begin
-          link = cinema_link_doc.get_attribute('href')
-          (link[0] == '/') ? "http://www.odeon.co.uk#{link}" : link
-        end
-      end
-
-      # Post code of the cinema
-      # @return [String]
-      def postal_code
-        return unless address_node
-        address_node.text.match(/[A-Z]{1,2}\d{1,2}[A-Z]?\s\d{1,2}[A-Z]{1,2}/)[0]
-      end
-
-      # The street adress of the cinema
-      # @return [String]
-      def street_address
-        return unless address_node
-        address_node.text.match(/\A\s+(\w+(\s\w+){0,})/)[1]
-      end
-
-      private
-
-      def self.id_from(link)
-        link.get_attribute('href').match(/\/(\d+)\/$/)[1].to_i
-      end
-
-      def self.cinema_links
-        @@cinema_links ||= begin
-          links = sitemap_doc.css(ALL_LINKS)
-          links.select { |link| link.get_attribute('href').match(/\/\d+\/$/) }
-        end
-      end
-
-      def self.sitemap_doc
-        @@sitemap_doc ||= Nokogiri::HTML(sitemap_response)
-      end
-
-      def self.sitemap_response
-        @@sitemap_response ||= Html::Website.new.sitemap
-      end
-
-      def address_node
-        cinema_doc.css(ADDRESS_REGEX)[0]
-      end
-
-      def cinema_response
-        @cinema_response ||= Html::Website.new.cinema(id)
-      end
-
-      def cinema_doc
-        @cinema_doc ||= Nokogiri::HTML(cinema_response)
-      end
-
-      def cinema_link_doc
-        self.class.cinema_links.select do |link|
-          link.get_attribute('href').include?("/#{id}/")
-        end.first
-      end
-    end
-  end
-end

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

@@ -1,160 +0,0 @@
-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