ratis 3.1.2 → 3.1.3

data/CHANGELOG

@@ -7,4 +7,7 @@
 
 3.1.2
 - NextBus#stop added
-- Contains info about the stop (:side, :stopid, :heading, :lat, :area, :servicetype, :route, :operator)
+- Contains info about the stop (:side, :stopid, :heading, :lat, :area, :servicetype, :route, :operator)
+
+3.1.3
+- Turns out that in the NextBus calls the <service> tag can come back as either a single node or list of nodes.  In one case savon turns this into an array, in the other case it's just a single entity.  Rewrote NextBus.where to handle these two cases, this also means NextBus would never really represent a single service.  Created a NextBus.services method that returns all these entities in a similar manner.  Update test specs

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ratis (3.1.1)
+    ratis (3.1.3)
       savon (< 2.0)
 
 GEM

data/lib/ratis.rb

@@ -1,4 +1,5 @@
 require 'savon'
+require 'ostruct'
 
 require 'ratis/closest_stop'
 require 'ratis/config'

data/lib/ratis/next_bus.rb

@@ -2,17 +2,47 @@ module Ratis
 
   class NextBus
 
-    attr_accessor :runs, :status, :sign, :routetype, :times, :direction, :stop
+    attr_accessor :stop, :services, :success
 
-    def initialize(service, _runs = [], _stop = {})
-      @runs      = _runs
-      @stop      = _stop
+    def initialize(response)
+      @success  = response.success?
+      @stop     = response.body[:nextbus_response][:atstop]
+      _services = @stop.delete(:service)
+
+      unless _services.is_a?(Array)
+        _services = [_services]
+      end
+
+      @services = _services.map do |service|
+        OpenStruct.new(:status      => service[:status],
+                       :sign        => service[:sign],
+                       :routetype   => service[:routetype],
+                       :times       => service[:times],
+                       :direction   => service[:direction],
+                       :servicetype => service[:servicetype],
+                       :route       => service[:route],
+                       :operator    => service[:operator],
+                       :trips       => service[:tripinfo].map do |ti|
+                                         OpenStruct.new(:triptime   => ti[:triptime],
+                                                        :block      => ti[:block],
+                                                        :tripid     => ti[:tripid],
+                                                        :exception  => ti[:exception],
+                                                        :skedtripid => ti[:skedtripid],
+                                                        :realtime   => OpenStruct.new(:valid            => ti[:realtime][:valid],
+                                                                                      :adherence        => ti[:realtime][:adherence],
+                                                                                      :estimatedtime    => ti[:realtime][:estimatedtime],
+                                                                                      :estimatedminutes => ti[:realtime][:estimatedminutes],
+                                                                                      :polltime         => ti[:realtime][:polltime],
+                                                                                      :trend            => ti[:realtime][:trend],
+                                                                                      :speed            => ti[:realtime][:speed],
+                                                                                      :reliable         => ti[:realtime][:reliable],
+                                                                                      :stopped          => ti[:realtime][:stopped],
+                                                                                      :lat              => ti[:realtime][:lat],
+                                                                                      :long             => ti[:realtime][:long] ))
+                                       end
+                       )
+      end
 
-      @status    = service[:status]
-      @sign      = service[:sign]
-      @routetype = service[:routetype]
-      @times     = service[:times]
-      @direction = service[:direction]
     end
 
     def self.where(conditions)
@@ -28,20 +58,19 @@ module Ratis
 
       raise ArgumentError.new('You must provide a stop ID') unless stop_id
 
-      Ratis.all_conditions_used? conditions
+      Ratis.all_conditions_used?(conditions)
 
       response = Request.get 'Nextbus', {'Stopid' => stop_id,
                                          'Appid' => app_id,
                                          'Date' => datetime.strftime("%m/%d/%Y"),
                                          'Time' => datetime.strftime("%I%M"),
                                          'Type' => type }
-      return [] unless response.success?
 
-      stop    = response.body[:nextbus_response][:atstop]
-      service = stop.delete(:service)
-      runs    = service.delete(:tripinfo)
+      NextBus.new(response)
+    end
 
-      NextBus.new service, runs, stop
+    def success?
+      @success
     end
 
     # Gets description of first stop

data/lib/ratis/version.rb

@@ -5,7 +5,7 @@ module Ratis
   def version
     @version ||= begin
 
-      string = '3.1.2'
+      string = '3.1.3'
 
       def string.parts
         split('.').map { |p| p.to_i }

data/spec/ratis/next_bus_spec.rb

@@ -8,87 +8,211 @@ describe Ratis::NextBus do
       config.namespace  = 'PX_WEB'
     end
 
-    @stop_id = 10050
     @time    = Chronic.parse('tomorrow at 6am')
   end
 
-  describe '#where' do
-    before do
-      # appid
-      # a short string that can be used to separate requests from different applications or different modules with
-      # Optional (highly recommended)
-      @conditions = {:stop_id      => @stop_id,
-                     :app_id       => 'ratis-specs',
-                     :type         => 'N',
-                     :datetime     => @time }
-    end
+  let(:empty_body){ {:nextbus_response => {:atstop => {:service => []}}} }
 
-    it 'returns the next 4 bus times' do
-      # raises exception when no runs available:
-      # Ratis::Errors::SoapError:
-      # SOAP - no runs available
-      response = Ratis::NextBus.where(@conditions.dup)
-      expect(response.runs).to have(4).items
+  describe '#success?' do
+    it "do something" do
+      pending
     end
+  end
 
-    it 'only makes one request' do
-      # false just to stop further processing of response
-      Ratis::Request.should_receive(:get).once.and_call_original
-      Ratis::NextBus.where(@conditions.dup)
-    end
+  describe '#where' do
+    describe 'single service return' do
+      before do
+        @stop_id = 10050
+        @conditions = {:stop_id      => @stop_id,
+                       :app_id       => 'ratis-specs', # a short string that can be used to separate requests from different applications or different modules with
+                       :type         => 'N',
+                       :datetime     => @time }
+      end
 
-    it 'requests the correct SOAP action' do
-      Ratis::Request.should_receive(:get) do |action, options|
-                       action.should eq('Nextbus')
-                       options["Stopid"].should eq(@stop_id)
-                       options["Appid"].should eq('ratis-specs')
-                       options["Date"].should eq(@time.strftime("%m/%d/%Y"))
-                       options["Time"].should eq(@time.strftime("%I%M"))
-                       options["Type"].should eq('N')
+      it 'returns the next 4 bus times' do
+        # raises exception when no runs available:
+        # Ratis::Errors::SoapError:
+        # SOAP - no runs available
+        response = Ratis::NextBus.where(@conditions.dup)
+        expect(response.services).to have(1).items
+      end
 
-                     end.and_return(double('response', :success? => false)) # false only to stop further running
+      it 'only makes one request' do
+        # false just to stop further processing of response
+        Ratis::Request.should_receive(:get).once.and_call_original
+        Ratis::NextBus.where(@conditions.dup)
+      end
 
-      Ratis::NextBus.where(@conditions.dup)
-    end
+      it 'requests the correct SOAP action' do
+        Ratis::Request.should_receive(:get) do |action, options|
+                         action.should eq('Nextbus')
+                         options["Stopid"].should eq(@stop_id)
+                         options["Appid"].should eq('ratis-specs')
+                         options["Date"].should eq(@time.strftime("%m/%d/%Y"))
+                         options["Time"].should eq(@time.strftime("%I%M"))
+                         options["Type"].should eq('N')
 
-    it "should set all the service values to instance vars" do
-      response = Ratis::NextBus.where(@conditions.dup)
-      expect(response).to be_a(Ratis::NextBus)
-      expect(response.status).to eq('N')
-      expect(response.sign).to eq('0 CENTRAL North to Dunlap/3rd St.')
-      expect(response.routetype).to eq('B')
-      expect(response.times).to eq("05:49 AM, 06:09 AM, 06:29 AM, 06:49 AM")
-      expect(response.direction).to eq('N')
-    end
+                       end.and_return(double('response', :success? => false, :body => empty_body)) # false only to stop further running
 
-    it "should raise error if datetime condition is not a DateTime or Time" do
-      lambda {
-        Ratis::NextBus.where(@conditions.dup.merge(:datetime => '01/01/2013'))
-      }.should raise_error(ArgumentError, 'If datetime supplied it should be a Time or DateTime instance, otherwise it defaults to Time.now')
+        Ratis::NextBus.where(@conditions.dup)
+      end
 
-      lambda {
-        Ratis::NextBus.where(@conditions.dup.merge(:datetime => Time.now))
-      }.should_not raise_error(ArgumentError)
+      it "should set all the service values to instance vars" do
+        response = Ratis::NextBus.where(@conditions.dup)
+        service = response.services.first
+        expect(response).to be_a(Ratis::NextBus)
+        expect(response.services).to be_a(Array)
 
-      lambda {
-        Ratis::NextBus.where(@conditions.dup.merge(:datetime => DateTime.today))
-      }.should_not raise_error(ArgumentError)
-    end
+        expect(service.status).to eq('N')
+        expect(service.sign).to eq('0 CENTRAL North to Dunlap/3rd St.')
+        expect(service.routetype).to eq('B')
+        expect(service.times).to eq("05:49 AM, 06:09 AM, 06:29 AM, 06:49 AM")
+        expect(service.direction).to eq('N')
+        expect(service.servicetype).to eq('W')
+        expect(service.route).to eq('0')
+        expect(service.operator).to eq('AP')
+      end
+
+      it "should raise error if datetime condition is not a DateTime or Time" do
+        lambda {
+          Ratis::NextBus.where(@conditions.dup.merge(:datetime => '01/01/2013'))
+        }.should raise_error(ArgumentError, 'If datetime supplied it should be a Time or DateTime instance, otherwise it defaults to Time.now')
 
-    it "should raise error if stop id is not provided" do
-      lambda {
-        Ratis::NextBus.where(@conditions.dup.merge(:stop_id => nil))
-      }.should raise_error(ArgumentError, 'You must provide a stop ID')
+        lambda {
+          Ratis::NextBus.where(@conditions.dup.merge(:datetime => Time.now))
+        }.should_not raise_error(ArgumentError)
+
+        lambda {
+          Ratis::NextBus.where(@conditions.dup.merge(:datetime => DateTime.today))
+        }.should_not raise_error(ArgumentError)
+      end
+
+      it "should raise error if stop id is not provided" do
+        lambda {
+          Ratis::NextBus.where(@conditions.dup.merge(:stop_id => nil))
+        }.should raise_error(ArgumentError, 'You must provide a stop ID')
+      end
+
+      it "should return an empty array if the api request isn't successful" do
+        Ratis::Request.should_receive(:get) do |action, options|
+                         action.should eq('Nextbus')
+                         options["Stopid"].should eq(@stop_id)
+                         options["Appid"].should eq('ratis-specs')
+                         options["Date"].should eq(@time.strftime("%m/%d/%Y"))
+                         options["Time"].should eq(@time.strftime("%I%M"))
+                         options["Type"].should eq('N')
+
+                       end.and_return(double('response', :success? => false, :body => empty_body)) # false only to stop further running
+
+        expect(Ratis::NextBus.where(@conditions.dup).services).to be_empty
+      end
     end
 
-    it "should return an empty array if the api request isn't successful" do
-      Ratis::Request.should_receive('get').
-                     with('Nextbus', {"Time"=>@time.strftime("%I%M"), "Type"=>"N", "Stopid"=>10050, "Date"=>@time.strftime("%m/%d/%Y"), "Appid"=>"ratis-specs"}).
-                     and_return(double('response', :success? => false))
-      expect(Ratis::NextBus.where(@conditions.dup)).to be_empty
+    describe 'multiple services returned' do
+      before do
+        @stop_id = 15894
+        @conditions = {:stop_id      => @stop_id,
+                       :app_id       => 'ratis-specs', # a short string that can be used to separate requests from different applications or different modules with
+                       :type         => 'N',
+                       :datetime     => @time }
+      end
+
+      it 'returns the next 4 bus times' do
+        # raises exception when no runs available:
+        # Ratis::Errors::SoapError:
+        # SOAP - no runs available
+        response = Ratis::NextBus.where(@conditions.dup)
+        expect(response.services).to have(2).items
+      end
+
+      it 'only makes one request' do
+        # false just to stop further processing of response
+        Ratis::Request.should_receive(:get).once.and_call_original
+        Ratis::NextBus.where(@conditions.dup)
+      end
+
+      it 'requests the correct SOAP action' do
+        Ratis::Request.should_receive(:get) do |action, options|
+                         action.should eq('Nextbus')
+                         options["Stopid"].should eq(@stop_id)
+                         options["Appid"].should eq('ratis-specs')
+                         options["Date"].should eq(@time.strftime("%m/%d/%Y"))
+                         options["Time"].should eq(@time.strftime("%I%M"))
+                         options["Type"].should eq('N')
+
+                       end.and_return(double('response', :success? => false, :body => empty_body)) # false only to stop further running
+
+        Ratis::NextBus.where(@conditions.dup)
+      end
+
+      it "should map all the services to service openstruct objects" do
+        response = Ratis::NextBus.where(@conditions.dup)
+        expect(response).to be_a(Ratis::NextBus)
+        expect(response.services).to be_a(Array)
+
+        service = response.services.first
+        expect(service).to be_a(OpenStruct)
+
+        expect(service.status).to eq('N')
+        expect(service.sign).to eq('108 Elliot West To Priest')
+        expect(service.routetype).to eq('B')
+        expect(service.times).to eq("06:46 AM, 07:46 AM, 08:46 AM, 09:46 AM")
+        expect(service.direction).to eq('W')
+        expect(service.servicetype).to eq('W')
+        expect(service.route).to eq('108')
+        expect(service.operator).to eq('AT')
+
+        service = response.services.last
+        expect(service).to be_a(OpenStruct)
+
+        expect(service.status).to eq('N')
+        expect(service.sign).to eq('108 Elliot West To Priest Via Sosmn/Bsnln')
+        expect(service.routetype).to eq('B')
+        expect(service.times).to eq("10:46 AM, 02:46 PM, 06:46 PM")
+        expect(service.direction).to eq('W')
+        expect(service.servicetype).to eq('W')
+        expect(service.route).to eq('108')
+        expect(service.operator).to eq('AT')
+      end
+
+      it "should raise error if datetime condition is not a DateTime or Time" do
+        lambda {
+          Ratis::NextBus.where(@conditions.dup.merge(:datetime => '01/01/2013'))
+        }.should raise_error(ArgumentError, 'If datetime supplied it should be a Time or DateTime instance, otherwise it defaults to Time.now')
+
+        lambda {
+          Ratis::NextBus.where(@conditions.dup.merge(:datetime => Time.now))
+        }.should_not raise_error(ArgumentError)
+
+        lambda {
+          Ratis::NextBus.where(@conditions.dup.merge(:datetime => DateTime.today))
+        }.should_not raise_error(ArgumentError)
+      end
+
+      it "should raise error if stop id is not provided" do
+        lambda {
+          Ratis::NextBus.where(@conditions.dup.merge(:stop_id => nil))
+        }.should raise_error(ArgumentError, 'You must provide a stop ID')
+      end
+
+      it "should return an empty array if the api request isn't successful" do
+        Ratis::Request.should_receive('get') do |action, options|
+                        action.should eq('Nextbus')
+                        options["Time"].should eq(@time.strftime("%I%M") )
+                        options["Type"].should eq("N")
+                        options["Stopid"].should eq(@stop_id)
+                        options["Date"].should eq(@time.strftime("%m/%d/%Y") )
+                        options["Appid"].should eq("ratis-specs")
+
+                      end.and_return(double('response', :success? => false, :body => empty_body))
+
+        expect(Ratis::NextBus.where(@conditions.dup).services).to be_empty
+      end
     end
   end
 
+
+
 end
 
 # EXAMPLE RESPONSE

data/spec/support/vcr_cassettes/Point2Point.yml

@@ -20,12 +20,12 @@ http_interactions:
         aW50MnBvaW50PjwvZW52OkJvZHk+PC9lbnY6RW52ZWxvcGU+
 
     headers: 
-      Accept: 
-      - "*/*"
       Soapaction: 
       - "\"PX_WEB#Point2point\""
       Content-Type: 
       - text/xml;charset=UTF-8
+      Accept: 
+      - "*/*"
       Content-Length: 
       - "576"
   response: 
@@ -33,14 +33,14 @@ http_interactions:
       code: 302
       message: Found
     headers: 
+      Server: 
+      - BigIP
+      Content-Length: 
+      - "0"
       Connection: 
       - Keep-Alive
       Location: 
       - http://www.iana.org/domains/example/
-      Content-Length: 
-      - "0"
-      Server: 
-      - BigIP
     body: 
       base64_string: ""
     http_version: 
@@ -51,26 +51,26 @@ http_interactions:
     body: 
       base64_string: |
         PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz48ZW52OkVu
-        dmVsb3BlIHhtbG5zOndzZGw9IlBYX1dFQiIgeG1sbnM6eHNkPSJodHRwOi8v
-        d3d3LnczLm9yZy8yMDAxL1hNTFNjaGVtYSIgeG1sbnM6eHNpPSJodHRwOi8v
-        d3d3LnczLm9yZy8yMDAxL1hNTFNjaGVtYS1pbnN0YW5jZSIgeG1sbnM6ZW52
-        PSJodHRwOi8vc2NoZW1hcy54bWxzb2FwLm9yZy9zb2FwL2VudmVsb3BlLyI+
-        PGVudjpCb2R5PjxQb2ludDJwb2ludCB4bWxucz0iUFhfV0VCIj48T3JpZ2lu
-        bG9uZz4tMTEyLjA5NzkwMzwvT3JpZ2lubG9uZz48RGVzdGluYXRpb25sYXQ+
-        MzMuNDQ3MDk4PC9EZXN0aW5hdGlvbmxhdD48RGF0ZT4wNi8wNi8yMDEzPC9E
-        YXRlPjxSb3V0ZXNvbmx5Plk8L1JvdXRlc29ubHk+PERlc3RpbmF0aW9ubG9u
-        Zz4tMTEyLjA3NzIxMzwvRGVzdGluYXRpb25sb25nPjxTdGFydHRpbWU+MTcw
-        MDwvU3RhcnR0aW1lPjxFbmR0aW1lPjE4MDA8L0VuZHRpbWU+PFJvdXRlcz4x
+        dmVsb3BlIHhtbG5zOmVudj0iaHR0cDovL3NjaGVtYXMueG1sc29hcC5vcmcv
+        c29hcC9lbnZlbG9wZS8iIHhtbG5zOndzZGw9IlBYX1dFQiIgeG1sbnM6eHNk
+        PSJodHRwOi8vd3d3LnczLm9yZy8yMDAxL1hNTFNjaGVtYSIgeG1sbnM6eHNp
+        PSJodHRwOi8vd3d3LnczLm9yZy8yMDAxL1hNTFNjaGVtYS1pbnN0YW5jZSI+
+        PGVudjpCb2R5PjxQb2ludDJwb2ludCB4bWxucz0iUFhfV0VCIj48RW5kdGlt
+        ZT4xODAwPC9FbmR0aW1lPjxEZXN0aW5hdGlvbmxhdD4zMy40NDcwOTg8L0Rl
+        c3RpbmF0aW9ubGF0PjxEZXN0aW5hdGlvbmxvbmc+LTExMi4wNzcyMTM8L0Rl
+        c3RpbmF0aW9ubG9uZz48RGF0ZT4wNi8wNi8yMDEzPC9EYXRlPjxPcmlnaW5s
+        b25nPi0xMTIuMDk3OTAzPC9PcmlnaW5sb25nPjxTdGFydHRpbWU+MTcwMDwv
+        U3RhcnR0aW1lPjxSb3V0ZXNvbmx5Plk8L1JvdXRlc29ubHk+PFJvdXRlcz4x
         PC9Sb3V0ZXM+PE9yaWdpbmxhdD4zMy40NDY5MzE8L09yaWdpbmxhdD48L1Bv
         aW50MnBvaW50PjwvZW52OkJvZHk+PC9lbnY6RW52ZWxvcGU+
 
     headers: 
       Soapaction: 
       - "\"PX_WEB#Point2point\""
-      Accept: 
-      - "*/*"
       Content-Type: 
       - text/xml;charset=UTF-8
+      Accept: 
+      - "*/*"
       Content-Length: 
       - "576"
   response: 
@@ -78,18 +78,18 @@ http_interactions:
       code: 200
       message: OK
     headers: 
-      Connection: 
-      - close
-      Soapserver: 
-      - SOAP::Lite/Perl/0.55
+      Server: 
+      - Apache/2.2.3 (CentOS)
       Date: 
-      - Thu, 06 Jun 2013 19:24:21 GMT
+      - Thu, 06 Jun 2013 23:02:44 GMT
       Content-Type: 
       - text/xml; charset=utf-8
+      Soapserver: 
+      - SOAP::Lite/Perl/0.55
       Content-Length: 
       - "4558"
-      Server: 
-      - Apache/2.2.3 (CentOS)
+      Connection: 
+      - close
     body: 
       base64_string: |
         PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz48U09BUC1F
@@ -196,5 +196,5 @@ http_interactions:
         RU5WOkVudmVsb3BlPg==
 
     http_version: 
-  recorded_at: Thu, 06 Jun 2013 19:24:21 GMT
+  recorded_at: Thu, 06 Jun 2013 23:02:44 GMT
 recorded_with: VCR 2.4.0

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ratis
 version: !ruby/object:Gem::Version 
-  hash: 7
+  hash: 5
   prerelease: 
   segments: 
   - 3
   - 1
-  - 2
-  version: 3.1.2
+  - 3
+  version: 3.1.3
 platform: ruby
 authors: 
 - Burst Software