bahn.rb 2.1.1 → 3.0.0

data/lib/bahn/bahn_route.rb

@@ -1,145 +1,208 @@
-# encoding: utf-8
-
-module Bahn
-	# The whole Route from A to B.
-	# This is created from the m.bahn.de detail view page and parses the given data.
-	# At the end you'll have a nice step by step navigation
-	# Feel free to refactor ;)
-	class Route
-		attr_accessor :price, :parts, :notes, :start_type, :target_type
-	
-		# Initialize with a Mechanize::Page and a specific type 
-		# The page should be the detail view of m.bahn.de
-		# Parameters:
-		# 	* page => Mechanize::Page
-		#		* type => :door2door or :station2station
-		def initialize page, options = {}
-			options = {:start_type => :address, :target_type => :address, :include_coords => true}.merge(options)
-			@do_load = options[:include_coords]
-			self.start_type = options[:start_type]
-			self.target_type = options[:target_type]
-			summary_time = page.search("//div[contains(@class, 'querysummary2')]").text.gsub("\n", " ").strip
-			html_parts = page.search("//div[contains(@class, 'haupt')]")
-			price = html_parts.pop.text
-			html_parts.pop
-
-			route = ""
-			html_parts.each do |part|
-				text = part.text.strip
-				next if text.start_with? "Reiseprofil" # not important
-				if text.starts_with?("Hinweis", "Aktuelle Informationen")
-					self.notes = "#{self.notes}\n#{text}" if !text.include?("Start/Ziel mit äquivalentem Bahnhof ersetzt")
-					next
-				end
-				
-				route << text << "\n"
-			end
-			route = route.split("\n")			
-			
-			idx = 3
-			@start = RoutePart.new
-			@target = RoutePart.new
-			if options[:start_type] == :address
-				@start.start = Station.new({"value" => route[0], :load => :foot, :do_load => @do_load})
-				@start.type = "Fußweg" # route[2]
-				@start.end_time = DateTime.parse(summary_time.split("-").first.gsub(".13", ".2013"))
-				@start.start_time = @start.end_time - route[1].to_i.minutes
-				@start.target = route[3]
-			elsif	options[:start_type] == :station
-				@start.start = Station.new({"value" => route[0], :load => :station, :do_load => @do_load})
-				@start.start_time = DateTime.parse(@date.to_s + route[1])
-				@start.type = route[2]
-				@start.end_time = DateTime.parse(@date.to_s + route[3])
-				@start.target = Station.new({"value" => route[4], :load => :station, :do_load => @do_load})
-				idx = 4
-			end
-			
-			@date = @start.start_time.to_date # otherwise all dates will be "today"
-			create_parts idx, route
-			if options[:target_type] == :station
-				@target = @parts.last
-			elsif options[:target_type] == :address
-				@target.type = "Fußweg"
-				@target.target = Station.new({"value" => route.last, :load => :foot, :do_load => @do_load})
-				if summary_time.split("-").last.strip.length != 5
-					# Date is included in the string
-					@target.end_time = DateTime.parse(summary_time.split("-").last.gsub(".13", ".2013"))
-				else
-					# no date given, use start date
-					@target.end_time = DateTime.parse("#{@start.start_time.to_date} #{summary_time.split("-").last}")
-				end
-				
-				@target.end_time += route[route.length-3].to_i.minutes				
-				@parts << @target
-			end
-		end
-		
-		# Start time of the  route
-		def start_time
-			@parts.first.start_time
-		end
-		
-		# End time of the route
-		def end_time
-			@parts.last.end_time
-		end
-		
-		# Starting point of the route
-		def start
-			@parts.first.start
-		end
-		
-		# Target point of the route
-		def target
-			@parts.last.target
-		end
-		
-		private
-		
-		# Create all general parts.
-		# Set @parts, @target and @date first!
-		def create_parts start_index, route
-			@parts = [@start]
-			i = start_index
-			done_anything = false
-			while i < route.length do
-				if route[i..i+4].count != 5 || route[i..i+4].include?(nil)
-					break
-				end
-				
-				done_anything = true
-				part = RoutePart.new
-				part.start = Station.new({"value" => route[i], :load => :station, :do_load => @do_load})
-				@parts.last.target = part.start
-				part.type = route[i+2].squeeze
-				
-				begin
-					part.start_time = DateTime.parse(@date.to_s + route[i+1])
-					part.end_time = DateTime.parse(@date.to_s + route[i+3])
-					part.target = Station.new({"value" => route[i+4], :load => :station, :do_load => @do_load})
-					i += 4
-				rescue ArgumentError
-					# occures if there is a "Fußweg" in between
-					part.start_time = @parts.last.end_time
-					part.end_time = part.start_time + route[i+1].to_i.minutes
-					part.target = Station.new({"value" => route[i+3], :load => :foot, :do_load => @do_load})
-					i += 3
-				end	
-				
-				part.end_time += 1.day if part.end_time.hour < @start.start_time.hour
-				part.start_time += 1.day if part.start_time.hour < @start.start_time.hour
-				
-				@target.start_time = part.end_time
-				@target.start = part.target
-				
-				# we don't want to show Fußwege from and to the same station
-				@parts << part unless part.start == part.target
-			end
-			
-			unless done_anything
-				@target.start_time = @parts.last.end_time
-				@target.start = @parts.last.start 
-			end
-		end
-	end
-end
+# encoding: utf-8
+
+module Bahn
+  # The whole Route from A to B.
+  # This is created from the m.bahn.de detail view page and parses the given data.
+  # At the end you'll have a nice step by step navigation
+  # Feel free to refactor ;)
+  class Route
+    attr_accessor :parts, :notes, :start_type, :target_type, :price
+    
+    # Initialize with a Mechanize::Page and a specific type 
+    # The page should be the detail view of m.bahn.de
+    # Parameters:
+    # 	* page => Mechanize::Page
+    #		* type => :door2door or :station2station
+    def initialize page, options = {}
+      options = {:start_type => :address, :target_type => :address, :include_coords => true}.merge(options)
+      @do_load = options[:include_coords]
+      self.start_type = options[:start_type]
+      self.target_type = options[:target_type]
+      self.notes = Array.new
+      summary_time = page.search("//div[contains(@class, 'querysummary2')]").text.strip
+      
+      # we'll add it for now...
+      #includes = ["Einfache Fahrt", "Preisinformationen", "Weitere Informationen", "Start/Ziel mit äquivalentem Bahnhof ersetzt"]
+      #start_withs = ["Reiseprofil", "Hinweis", "Aktuelle Informationen"]
+      notes = Array.new
+      #notes << page.search("//div[contains(@class, 'haupt rline')]").map(&:text).map(&:strip)
+      notes << page.search("//div[contains(@class, 'red bold haupt')]").map(&:text).map(&:strip)
+      notes.each do |note|
+        self.notes << note if note.size > 0
+      end
+
+      self.price = parse_price(page.search("//div[contains(@class, 'formular')]").map(&:text).map(&:strip))
+
+      change = page.search("//div[contains(@class, 'routeStart')]")
+      name = station_to_name change
+
+      type = page.search("//div[contains(@class, 'routeStart')]/following::*[1]").text.strip
+      last_lines = get_lines(change)
+
+      part = RoutePart.new
+      part.type = type
+      part.start_time = parse_date(summary_time.split("\n")[0...2].join(" "))
+      part.start_time -= last_lines.last.to_i.minutes if options[:start_type] == :address
+      part.start_delay = parse_delay(summary_time.split("\n")[0...2].join(" "))
+      part.start = Station.new({"value" => name, :load => options[:start_type] == :address ? :foot : :station, :do_load => @do_load})
+      part.platform_start = parse_platform(last_lines.last)
+
+      @parts = [part]
+      
+      page.search("//div[contains(@class, 'routeChange')]").each_with_index do |change, idx|
+        part = RoutePart.new
+        name = station_to_name change
+        type = page.search("//div[contains(@class, 'routeChange')][#{idx+1}]/following::*[1]").text.strip
+        lines = change.text.split("\n")
+        
+        part.type = type
+        part.start = Station.new({"value" => name, :load => :station, :do_load => @do_load})
+        
+        lines = get_lines(change)
+        if lines.last.start_with?("ab")
+          part.start_time = parse_date(lines.last)
+          part.start_delay = parse_delay(lines.last)
+          part.platform_start = parse_platform(lines.last)
+          unless lines.first.starts_with?("an")
+            @parts.last.end_time = @parts.last.start_time + last_lines.last.to_i.minutes
+          end
+        end
+        
+        if lines.first.starts_with?("an")
+          @parts.last.end_time = parse_date(lines.first)
+          @parts.last.target_delay = parse_delay(lines.first)
+          @parts.last.platform_target = parse_platform(lines.first)
+          unless lines.last.start_with?("ab")
+            # Fußweg for part
+            part.start_time = @parts.last.end_time
+          end
+        end
+        
+        last_lines = lines
+        
+        @parts.last.target = part.start
+        @parts << part #unless @parts.last.start == part.start
+      end
+      
+      
+      change = page.search("//div[contains(@class, 'routeEnd')]")
+      name = station_to_name change
+      @parts.last.target = Station.new({"value" => name, :load => options[:target_type] == :address ? :foot : :station, :do_load => @do_load})
+      lines = get_lines(change)
+
+      if lines.first.starts_with?("an")
+        @parts.last.end_time = parse_date(lines.first)
+        @parts.last.target_delay = parse_delay(lines.first)
+        @parts.last.platform_target = parse_platform(lines.first)
+      else
+        @parts.last.end_time = @parts.last.start_time + last_lines.last.to_i.minutes
+      end
+
+      
+    end
+    
+    # Start time of the  route
+    def start_time
+      @parts.first.start_time
+    end
+    
+    # End time of the route
+    def end_time
+      @parts.last.end_time
+    end
+
+    # Duration of a route
+    def duration
+      end_time_plus_delay = end_time + @parts.last.target_delay
+      duration_in_s = end_time_plus_delay.to_i - start_time.to_i
+      return duration_in_s
+    end
+
+    # Starting point of the route
+    def start
+      @parts.first.start
+    end
+    
+    # Target point of the route
+    def target
+      @parts.last.target
+    end
+
+    def has_delay?
+      @parts.any? { |part| (part.start_delay > 0 || part.target_delay > 0) }
+    end
+    
+    private
+    
+    def station_to_name change
+      change.search("span").select{|s| s.attributes["class"].value != "red"}.inject(" "){|r, s| r << s.text}.strip.gsub(/\+\d+/, "")
+    end
+    
+    def get_lines change
+      change.text.split("\n").reject{|s| s.to_s.length == 0}
+    end
+
+    def parse_price(to_parse)
+      return Array.new unless to_parse.first.match("EUR")
+      tags = to_parse.uniq.map { |p| p.split(/\d+\,\d{1,2}.EUR/) }.flatten
+      tags.map! { |t| t.gsub(/\p{Space}/, " ").strip } # remove ugly whitespaces: ruby >= 1.9.3
+      prices = to_parse.uniq.map { |p| p.scan(/\d+\,\d{1,2}.EUR/) }.flatten.map { |p| p.gsub(",",".").to_f }
+      price_information = Array.new
+      (0...prices.size).each do |idx|
+        price_information << {
+          :price => prices[idx],
+          :class => tags[idx+1].scan(/\d\.\sKlasse/).first.scan(/\d/).first,
+          :details => tags[idx+1].split(/\d\.\sKlasse/).last
+        }
+      end
+
+      return price_information
+    end
+
+    def parse_platform(to_parse)
+      return to_parse.split("Gl.").last.strip if to_parse.match("Gl.")
+      return nil
+    end
+
+    def parse_delay(to_parse)
+      to_parse = to_parse.split("+") # + sign indicates delay information
+
+      if to_parse.size > 1 # extract delay information
+        delay_information = to_parse.last.split.first.to_i
+      else
+        delay_information = 0
+      end
+      return delay_information
+    end
+
+    def parse_date to_parse
+      to_parse = to_parse.split("+") # clears time errors e.g.: "an 18:01 +4 Gl. 17"
+
+      # fix number of year digits from 2 to 4
+      to_parse = to_parse.first.gsub(".#{DateTime.now.year.to_s[2..4]} ", ".#{DateTime.now.year.to_s} ")
+
+      # fix missing year information in route parts (interesting for
+      # past or future connections)
+      unless to_parse.match(/\d{1,2}\.\d{1,2}\.\d{4}/)
+        tmp_date = DateTime.parse(to_parse[/\d{1,2}:\d{1,2}/])
+
+        tmp_date = DateTime.new(self.start_time.year, 
+                                self.start_time.month, 
+                                self.start_time.day,
+                                tmp_date.hour, 
+                                tmp_date.min, 
+                                tmp_date.sec)
+
+        tmp_date = tmp_date +1 if tmp_date < self.start_time
+        to_parse = tmp_date.to_s
+      end
+
+      to_parse = DateTime.parse(to_parse).to_s
+
+      # fix timezone
+      time_zone = DateTime.now.in_time_zone("Berlin").strftime("%z")
+      to_parse = to_parse.gsub("+00:00", time_zone).gsub("+0000", time_zone)
+      return DateTime.parse(to_parse)
+    end
+  end
+end

data/lib/bahn/bahn_routepart.rb

@@ -1,34 +1,55 @@
-# encoding: utf-8
-
-module Bahn
-	# Route Parts show a small step of the route from A to B with one specific type of transportation
-	# Example: "Am 2013-02-01 von 17:33 bis 17:47 : Heerdter Sandberg U, Düsseldorf nach Düsseldorf Hauptbahnhof via U 7"
-	class RoutePart
-		attr_accessor :start, :target, :type, :price, :start_time, :end_time
-		
-		# Return a nicely formatted route
-		# Raises errors if not everything is set properly
-		def to_s
-			"Am #{start_time.to_date} von #{start_time.to_formatted_s :time} bis #{end_time.to_date.to_s + ' ' if end_time.to_date != start_time.to_date}#{end_time.to_formatted_s :time} : #{start} nach #{target} via #{type}"
-		end
-		
-		# Set the type, e.g. Fußweg
-		def type= val
-			@type = val.squeeze(" ")
-		end
-		
-		def transport_type
-			short_type = self.type.split.first.downcase
-			if ["str", "u", "s", "re", "erb", "ic", "ice"].include? short_type
-				return :train
-			elsif ["bus", "ne"].include? short_type
-				return :bus
-			elsif "Fußweg" == short_type
-				return :foot
-			end
-			
-			# nothing else works
-			self.type
-		end
-	end
-end
+# encoding: utf-8
+
+module Bahn
+  # Route Parts show a small step of the route from A to B with one specific type of transportation
+  # Example: "Am 2013-02-01 von 17:33 bis 17:47 : Heerdter Sandberg U, Düsseldorf nach Düsseldorf Hauptbahnhof via U 7"
+  class RoutePart
+    attr_accessor :start, :target, :type, :platform_start, :platform_target, :price, :start_time, :end_time, :start_delay, :target_delay
+    
+    def initialize
+      @start_delay = 0
+      @target_delay = 0
+    end
+
+    # Return a nicely formatted route
+    # Raises errors if not everything is set properly
+    def to_s
+      "Am %s von %s%s bis %s%s: %s (Gl. %s) nach %s (Gl. %s) via %s" % 
+        [ start_time.to_date,
+          start_time.to_formatted_s(:time),
+          (start_delay > 0 ? " (+%i)" % start_delay : ""),
+          (end_time.to_date != start_time.to_date ? end_time.to_date.to_s + ' ' : "") + end_time.to_formatted_s(:time),
+          target_delay > 0 ? " (+%i)" % target_delay : "",
+          start.name, platform_start, target.name, platform_target, type]
+    end
+
+    # Set the type, e.g. Fußweg
+    def type= val
+      @type = val.squeeze(" ")
+    end
+    
+    def transport_type
+      short_type = self.type.split.first.downcase
+      if ["str", "u", "s", "re", "erb", "ic", "ice"].include? short_type
+        return :train
+      elsif ["bus", "ne"].include? short_type
+        return :bus
+      elsif "Fußweg" == short_type
+        return :foot
+      end
+      
+      # nothing else works
+      self.type
+    end
+
+    def ==(rp)
+      self.start == rp.start &&
+        self.target == rp.target &&
+        self.type == rp.type &&
+        self.platform_start == rp.platform_start &&
+        self.platform_target == rp.platform_target && 
+        self.start_time == rp.start_time &&
+        self.end_time == rp.end_time
+    end
+  end
+end

data/lib/bahn/bahn_station.rb

@@ -1,36 +1,50 @@
-module Bahn
-	class Station
-		attr_accessor :lat, :lon, :distance, :name
-		
-		def initialize json={}		
-			self.name = json["value"] unless json["value"].nil?
-			
-			if json[:do_load]
-				station = Agent.new.find_station(name) if json[:load] == :station			
-				station = Agent.new.find_address(name) if json[:load] == :foot
-			end
-			
-			if station.nil?
-				self.lat = json["ycoord"].insert(-7, ".") unless json["ycoord"].nil?
-				self.lon = json["xcoord"].insert(-7, ".") unless json["xcoord"].nil?
-			else
-				self.lat = station.lat
-				self.lon = station.lon
-			end
-		end
-		
-		def to_s
-			"#{self.name} (#{self.lat},#{self.lon})"
-		end
-		
-		def to_coordinates
-			[lat, lon]
-		end
-		alias_method :coordinates, :to_coordinates
-		
-		def == other
-			return false if other.nil?
-			other.name == self.name
-		end
-	end
-end
+module Bahn
+	class Station
+		attr_accessor :lat, :lon, :distance, :name, :station_type
+		
+		def initialize json={}		
+			self.name = json["value"].to_s.gsub("(S-Bahn)", "(S)") unless json["value"].nil?
+			
+			if json[:do_load]
+				station = Agent.new.find_station(name) if json[:load] == :station
+				station = Agent.new.find_address(name) if json[:load] == :foot
+			end
+			
+			if station.nil?
+				self.lat = json["ycoord"].insert(-7, ".") unless json["ycoord"].nil?
+				self.lon = json["xcoord"].insert(-7, ".") unless json["xcoord"].nil?
+			else
+				self.lat = station.lat
+				self.lon = station.lon
+			end
+		end
+		
+		def to_s
+                  return "#{self.name}" if (self.lat.nil? || self.lon.nil?)
+                  return "#{self.name} (#{self.lat},#{self.lon})"
+		end
+		
+		def to_coordinates
+			[lat, lon]
+		end
+		alias_method :coordinates, :to_coordinates
+		
+		def == other
+			return false if other.nil?
+			remove_parenthesis(other.name) == remove_parenthesis(name)
+		end
+		
+		
+		#############################################
+		private
+		#############################################
+		
+		# Often we have stations like "Berlin Gesundbrunnen (S)" and "Berlin Gesundbrunnen" 
+		# we want these stations to be different
+		def remove_parenthesis string
+			x = string.dup
+			while x.gsub!(/\([^()]*\)/,""); end
+			x.strip
+		end
+	end
+end