ratis 2.5.2.1

data/lib/ratis/landmark_category.rb

@@ -0,0 +1,22 @@
+module Ratis
+
+  class LandmarkCategory
+
+    attr_accessor :type, :description
+
+    def self.all
+
+      response = Request.get 'Getcategories'
+      return [] unless response.success?
+
+      response.to_array(:getcategories_response, :types, :typeinfo).map do |typeinfo|
+        atis_landmark_category = LandmarkCategory.new
+        atis_landmark_category.type = typeinfo[:type]
+        atis_landmark_category.description = typeinfo[:description]
+        atis_landmark_category
+      end
+    end
+
+  end
+
+end

data/lib/ratis/location.rb

@@ -0,0 +1,71 @@
+module Ratis
+
+  class Location
+
+    attr_accessor :name, :area, :response, :areacode, :latitude, :longitude, :landmark_id, :address, :startaddr, :endaddr, :address_string
+
+    def self.where(conditions)
+      location = conditions.delete :location
+      media = (conditions.delete(:media) || :w).to_s.upcase
+      max_answers = conditions.delete(:max_answers) || 20
+
+      raise ArgumentError.new('You must provide a location') unless location
+      raise ArgumentError.new('You must provide media of A|W|I') unless ['A','W','I'].include? media
+      raise ArgumentError.new('You must provide a numeric max_answers') unless (Integer max_answers rescue false)
+      Ratis.all_conditions_used? conditions
+
+      response = Request.get 'Locate', {'Location' => location, 'Media' => media, 'Maxanswers' => max_answers}
+      return [] unless response.success?
+
+      meta = response.to_hash[:locate_response]
+      locations = response.to_array :locate_response, :location
+
+      locations.map do |location_hash|
+        location = Ratis::Location.new
+        location.name = location_hash[:name]
+        location.area = location_hash[:area]
+        location.response = meta[:responsecode]
+        location.areacode = location_hash[:areacode]
+        location.latitude = location_hash[:latitude]
+        location.longitude = location_hash[:longitude]
+        location.landmark_id = location_hash[:landmarkid] || 0
+        location.address = location_hash[:address] || ''
+        location.startaddr = location_hash[:startaddr] || ''
+        location.endaddr = location_hash[:endaddr] || ''
+        location.address_string = build_address_string location_hash
+        location
+      end
+    end
+
+    def to_a
+      [latitude, longitude, name, landmark_id]
+    end
+
+    def to_hash
+      keys = [:latitude, :longitude, :name, :area, :address, :startaddr, :endaddr, :address_string, :landmark_id]
+      Hash[keys.map { |k| [k, send(k)] }]
+    end
+
+  private
+
+    def self.build_address_string(location_hash)
+      address_string = ''
+      address = location_hash[:address]
+      name = location_hash[:name]
+      area = location_hash[:area]
+
+      if !address.blank?
+        address_string << "#{address} #{name} (in #{area})"
+      else
+        startaddr = location_hash[:startaddr]
+        if !startaddr.blank?
+          endaddr = location_hash[:endaddr]
+          address_string << "#{startaddr} - #{endaddr} #{name} (in #{area})"
+        else
+          address_string << "#{name} (in #{area})"
+        end
+      end
+    end
+  end
+
+end

data/lib/ratis/next_bus.rb

@@ -0,0 +1,93 @@
+module Ratis
+
+  class NextBus
+
+    attr_accessor :stops, :runs
+
+    # Initializes a NextBus object with stops and runs.
+    # @return     [NextBus]
+    #
+    # == Parameters:
+    #
+    # [stops]    <em>Optional</em> - 
+    #            An array of stops. Defaults to empty array.
+    # [runs]     <em>Optional</em> - 
+    #            An array of runs. Defaults to empty array.
+
+    def initialize(_stops = [], _runs = [])
+      @stops, @runs = _stops, _runs
+    end
+
+    # Returns results of NextBus query containing arrays of stops and runs.
+    # @return     [NextBus] containing next buses.
+    #
+    # == Parameters:
+    #
+    # Takes hash of conditions
+    #
+    # [option1]      <b>Required</b> - 
+    #                Description of required param
+    # [option2]      <em>Optional</em> - 
+    #                Description of optional param
+    # [option3]      <em>Optional</em> - 
+    #                Description of optional param
+    # [option4]      <em>Optional</em> - 
+    #                Description of optional param
+
+    def self.where(conditions)
+      stop_id = conditions.delete :stop_id
+      app_id  = conditions.delete(:app_id) || 'na'
+
+      raise ArgumentError.new('You must provide a stop ID') unless stop_id
+      Ratis.all_conditions_used? conditions
+
+      response = Request.get 'Nextbus2', { 'Stopid' => stop_id, 'Appid' => app_id }
+      return [] unless response.success?
+
+      stops = response.to_array :nextbus2_response, :stops, :stop
+      runs  = response.to_array :nextbus2_response, :runs, :run
+
+      NextBus.new stops, runs
+    end
+
+    # Gets description of first stop
+    # @return [String] Description of first stop or nil.
+
+    def first_stop_description
+      stops.first ? stops.first[:description] : nil
+    end
+
+    # Details of NextBus instance in a hash.
+    # @return     [Hash] NextBus details in a hash.
+
+    def to_hash
+      { :stopname => first_stop_description,
+        :signs    => runs.map { |run| run[:sign] }.uniq,
+        :runs     => runs.map do |run|
+          { :time      => run[:estimatedtime],
+            :sign      => run[:sign],
+            :adherence => run[:adherence],
+            :route     => run[:route]
+          }
+        end
+      }
+    end
+
+    # Details of NextBus instance in a hash to be transformed to xml
+    # @private
+
+    def to_hash_for_xml
+      { :stopname => first_stop_description,
+        :runs     => runs.map do |run|
+          { :time           => run[:estimatedtime],
+            :scheduled_time => run[:triptime],
+            :sign           => run[:sign],
+            :adherence      => run[:adherence],
+            :route          => run[:route]
+          }
+        end
+      }
+    end
+  end
+
+end

data/lib/ratis/point_2_point.rb

@@ -0,0 +1,112 @@
+module Ratis
+
+  class Point2Point
+
+    def self.where(conditions)
+      routes_only = conditions.delete(:routes_only)
+
+      origin_lat = conditions.delete(:origin_lat).to_f
+      origin_long = conditions.delete(:origin_long).to_f
+      destination_lat = conditions.delete(:destination_lat).to_f
+      destination_long = conditions.delete(:destination_long).to_f
+
+      date = conditions.delete :date
+      start_time = conditions.delete :start_time
+      end_time = conditions.delete :end_time
+
+      raise ArgumentError.new("You must specify routes only with true, false, 'y' or 'n'") unless routes_only.y_or_n rescue false
+
+      raise ArgumentError.new('You must provide an origin latitude') unless Ratis.valid_latitude? origin_lat
+      raise ArgumentError.new('You must provide an origin longitude') unless Ratis.valid_longitude? origin_long
+      raise ArgumentError.new('You must provide an destination latitude') unless Ratis.valid_latitude? destination_lat
+      raise ArgumentError.new('You must provide an destination longitude') unless Ratis.valid_longitude? destination_long
+
+      raise ArgumentError.new('You must provide a date DD/MM/YYYY') unless DateTime.strptime(date, '%d/%m/%Y') rescue false
+      raise ArgumentError.new('You must provide a start time as 24-hour HHMM') unless DateTime.strptime(start_time, '%H%M') rescue false
+      raise ArgumentError.new('You must provide an end time as 24-hour HHMM') unless DateTime.strptime(end_time, '%H%M') rescue false
+
+      Ratis.all_conditions_used? conditions
+
+      response = Request.get 'Point2point', 'Routesonly' => routes_only.y_or_n.upcase,
+        'Originlat' => origin_lat, 'Originlong' => origin_long,
+        'Destinationlat' => destination_lat, 'Destinationlong' => destination_long,
+        'Date' => date, 'Starttime' => start_time, 'Endtime' => end_time
+
+      return nil unless response.success?
+
+      return parse_routes_only_yes response if routes_only.y_or_n.downcase == 'y'
+      return parse_routes_only_no response if routes_only.y_or_n.downcase == 'n'
+
+      nil
+    end
+
+  private
+
+    def self.parse_routes_only_yes(response)
+      response.to_array(:point2point_response, :routes, :service).map do |service|
+        atis_service = Service.new
+        atis_service.route = service[:route]
+        atis_service.direction = service[:direction]
+        atis_service.service_type = service[:servicetype]
+        atis_service.signage = service[:signage]
+        atis_service.route_type = service[:routetype]
+        atis_service
+      end
+    end
+
+    def self.parse_routes_only_no(response)
+      return nil unless response.success?
+
+      atis_schedule = Schedule.new
+      atis_schedule.groups = response.to_array(:point2point_response, :groups, :group).map do |group|
+        atis_schedule_group = ScheduleGroup.new
+
+        # Point2point 1.3 uses inconsistent tag naming, thus: <onstop> <onwalk...>, but <offstop> <offstopwalk...>
+        # this docs says this is fixed in 1.4, so watch out
+        atis_schedule_group.on_stop = atis_stop_from_hash 'on', group[:onstop]
+        atis_schedule_group.off_stop = atis_stop_from_hash 'offstop', group[:offstop]
+
+        atis_schedule_group.trips = group.to_array(:trips, :trip).map do |trip|
+          atis_trip = ScheduleTrip.new
+          atis_trip.on_time = trip[:ontime]
+          atis_trip.off_time = trip[:offtime]
+
+          atis_trip.service = trip.to_array(:service).map do |service|
+            atis_service = Service.new
+
+            atis_service.route = service[:route]
+            atis_service.direction = service[:direction]
+            atis_service.service_type = service[:servicetype]
+            atis_service.signage = service[:signage]
+            atis_service.route_type = service[:routetype]
+            atis_service.exception = service[:exception]
+            atis_service
+          end.first
+
+          atis_trip
+        end
+
+        atis_schedule_group
+      end
+
+      atis_schedule
+    end
+
+    def self.atis_stop_from_hash(prefix, stop)
+      return nil if stop.blank?
+
+      atis_stop = Stop.new
+      atis_stop.description = stop[:description]
+      atis_stop.atis_stop_id = stop[:atisstopid].to_i
+      atis_stop.latitude = stop[:lat].to_f
+      atis_stop.longitude = stop[:long].to_f
+
+      # It appears that both *walk and *walkdist are used for the walk distance, covering both here
+      atis_stop.walk_dist = (stop["#{prefix}walk".to_sym] || stop["#{prefix}walkdist".to_sym]).to_f
+      atis_stop.walk_dir = stop["#{prefix}walkdir".to_sym]
+      atis_stop.walk_hint = stop["#{prefix}walkhint".to_sym]
+      atis_stop
+    end
+  end
+
+end

data/lib/ratis/request.rb

@@ -0,0 +1,39 @@
+module Ratis
+
+  class Request
+
+    extend Savon::Model
+
+    def initialize(config = nil)
+      config = Ratis.config if config.nil?
+      raise Errors::ConfigError('It appears that Ratis.configure has not been called') unless config.valid?
+      self.class.client do
+        wsdl.endpoint     = Ratis.config.endpoint
+        wsdl.namespace    = Ratis.config.namespace
+        http.proxy        = Ratis.config.proxy unless Ratis.config.proxy.blank?
+        http.open_timeout = Ratis.config.timeout unless Ratis.config.timeout.blank?
+      end
+    rescue ArgumentError => e
+      raise ArgumentError.new 'Invalid ATIS SOAP server configuration: ' + e.message
+    end
+
+    def self.get(action, params = {})
+      begin
+        req      = new Ratis.config
+        response = client.request action, :soap_action => "#{Ratis.config.namespace}##{action}", :xmlns => Ratis.config.namespace do
+          soap.body = params unless params.blank?
+        end
+
+        version = response.to_hash["#{action.downcase}_response".to_sym][:version]
+
+        response
+      rescue Errno::ECONNREFUSED => e
+        raise Errno::ECONNREFUSED.new 'Refused request to ATIS SOAP server'
+      rescue Savon::SOAP::Fault => e
+        raise Errors::SoapError.new e
+      end
+    end
+
+  end
+
+end

data/lib/ratis/route.rb

@@ -0,0 +1,31 @@
+module Ratis
+
+  class Route
+
+    attr_accessor :short_name, :directions
+
+    def self.all
+      response = Request.get 'Allroutes'
+      return [] unless response.success?
+
+      routes = response.to_hash[:allroutes_response][:routes].split(/\n/)
+      atis_routes = routes.map do |r|
+        r.strip!
+        next if r.blank?
+        r = r.split(/, /)
+        Route.new r[0].strip, r[1..-1].map(&:strip)
+      end
+      atis_routes.compact
+    end
+
+    def initialize(short_name, directions)
+      self.short_name = short_name
+      self.directions = directions
+    end
+
+    def timetable(conditions)
+      Timetable.where conditions.merge :route_short_name => short_name
+    end
+  end
+
+end

data/lib/ratis/route_stops.rb

@@ -0,0 +1,40 @@
+module Ratis
+
+  ################################# EXAMPLE ############################################
+  #
+  # Ratis::RouteStops.all :route => 8, :direction => 'S', :order => 'S'
+  #
+  ######################################################################################
+
+  class RouteStops
+
+    def self.all(conditions)
+      route = conditions.delete :route
+      direction = conditions.delete(:direction).to_s.upcase
+      order = conditions.delete(:order).to_s.upcase
+
+      raise ArgumentError.new('You must provide a route') unless route
+      raise ArgumentError.new('You must provide a direction') unless direction
+
+      Ratis.all_conditions_used? conditions
+
+      request_params = {'Route' => route, 'Direction' => direction }
+      request_params.merge! order ? { 'Order' => order } : {}
+      response = Request.get 'Routestops', request_params
+
+      return [] unless response.success?
+
+      response.to_hash[:routestops_response][:stops][:stop].map do |s|
+        stop = Stop.new
+        stop.description = s[:description]
+        stop.area = s[:area]
+        stop.atis_stop_id = s[:atisstopid]
+        stop.stop_seq = s[:stopseq]
+        stop.latitude, stop.longitude = s[:point].split ','
+        stop
+      end
+    end
+
+  end
+
+end

data/lib/ratis/schedule.rb

@@ -0,0 +1,7 @@
+module Ratis
+
+  class Schedule < Struct.new(:groups)
+
+  end
+
+end

data/lib/ratis/schedule_group.rb

@@ -0,0 +1,7 @@
+module Ratis
+
+  class ScheduleGroup < Struct.new(:on_stop, :off_stop, :trips)
+
+  end
+
+end

data/lib/ratis/schedule_nearby.rb

@@ -0,0 +1,79 @@
+module Ratis
+
+  class ScheduleNearby
+
+    attr_accessor :atstops
+
+    def self.where(conditions)
+      latitude = conditions.delete :latitude
+      longitude = conditions.delete :longitude
+      date = conditions.delete :date
+      time = conditions.delete :time
+      window = conditions.delete :window
+      walk_distance = conditions.delete :walk_distance
+      landmark_id = conditions.delete :landmark_id
+      stop_id = conditions.delete(:stop_id) || ''
+      app_id = conditions.delete(:app_id) || 'na'
+
+      raise ArgumentError.new('You must provide latitude') unless latitude
+      raise ArgumentError.new('You must provide longitude') unless longitude
+      raise ArgumentError.new('You must provide date') unless date
+      raise ArgumentError.new('You must provide time') unless time
+      raise ArgumentError.new('You must provide window') unless window
+      raise ArgumentError.new('You must provide walk_distance') unless walk_distance
+      raise ArgumentError.new('You must provide landmark_id') unless landmark_id
+      Ratis.all_conditions_used? conditions
+
+      response = Request.get 'Schedulenearby',
+        {'Locationlat' => latitude, 'Locationlong' => longitude,
+         'Date' => date, 'Time' => time, 'Window' => window, 'Walkdist' => walk_distance,
+         'Landmarkid' => landmark_id, 'Stopid' => stop_id, 'Appid' => app_id
+        }
+
+      return [] unless response.success?
+
+      atstops = response.to_array :schedulenearby_response, :atstop
+      atstops.map do |atstop|
+        atstop[:services] = atstop.to_array :service
+
+        atstop[:services].map do |service|
+          service[:tripinfos] = service.to_array :tripinfo
+        end
+      end
+
+      schedule_nearby = ScheduleNearby.new
+      schedule_nearby.atstops = atstops
+
+      schedule_nearby
+    end
+
+    def to_hash
+      {
+        :atstops => atstops.map do |atstop|
+          {
+            :description    => atstop[:description],
+            :walkdist       => atstop[:walkdist],
+            :walkdir        => atstop[:walkdir],
+            :stopid         => atstop[:stopid],
+            :lat            => atstop[:lat],
+            :long           => atstop[:long],
+            :services       => atstop[:services].map do |service|
+              {
+                :route      => service[:route],
+                :routetype  => service[:routetype],
+                :operator   => service[:operator],
+                :sign       => service[:sign],
+                :times      => service[:times],
+                :trips      => service[:tripinfos].map do |tripinfo|
+                  { :triptime => tripinfo[:triptime] }
+                end
+              }
+            end
+          }
+        end
+      }
+    end
+
+  end
+
+end