undergrounder 0.1.0

data/bin/undergrounder

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+require 'undergrounder'
+require 'optparse'
+
+options = {}
+
+opt_parser = OptionParser.new do |opts|
+  opts.banner = "Usage: undergrounder [options]"
+
+  opts.on("-i", "--interactive", "Start an interactive tube search session") do |input|
+  	puts "Welcome to Undergrounder version #{Undergrounder::VERSION}!"
+  	puts "Enjoy your travel!"
+    puts "Please, enter a point of origin:"
+    source = gets.chomp
+    puts "Great!Now, enter a destination:"
+    destination = gets.chomp
+    puts "Calculating shortest path...."
+    Undergrounder.start!(source, destination)
+  end
+
+  opts.on("-s", "--start-server [OPT]", "Start an internal server") do |output|
+    puts "System is starting. Please , launch your browser and go to http://localhost:3000"
+    Dir.chdir(File.join(File.dirname(File.expand_path(__FILE__)), "../vendor/web_finder/")) do
+    	system("padrino start")
+    end
+  end
+end
+
+opt_parser.parse!

data/lib/undergrounder.rb

@@ -0,0 +1,167 @@
+require "undergrounder/version"
+require 'yaml'
+
+module Undergrounder
+ 	def self.start!(source, destination, web_request=false)
+ 		test = Undergrounder::Graph.new
+ 		test.load_from_yaml()
+ 		test.print_shortest_paths(source, destination, web_request)
+ 	end
+
+ 	# Graph Initialization
+ 	class Graph
+ 		attr_reader :graph, :nodes, :prev_station, :distance_modifier
+		def initialize
+			@graph = {}	
+			@nodes = Array.new		 
+			@INFINITY = 1 << 64 
+			@tube_list = []
+		end
+			
+		# Edge data structure: { "Euston" => { "Warren Street" => [ 1, ["Northern", "Victoria"] ] ]}
+		# In this way i got track of all the lines between 2 stations
+		def add_edge(source, target, weight, line)
+			if (not @graph.has_key?(source))	 
+				@graph[source] = {target => [weight, [line]  ] }		 
+			elsif(@graph[source].has_key?(target))
+				@graph[source][target][1] << line
+				@graph[source][target][1].uniq!
+			else
+				@graph[source][target] = [weight , [line] ]   
+			end
+			
+			
+			if (not @graph.has_key?(target))
+				@graph[target] = {source => [weight, [line]] }
+			elsif(@graph[target].has_key?(source))
+				@graph[target][source][1] << line
+				@graph[target][source][1].uniq!
+			else
+				@graph[target][source] = [weight, [line] ] 
+			end
+
+
+
+			if (not @nodes.include?(source))	
+				@nodes << source
+			end
+			if (not @nodes.include?(target))
+				@nodes << target
+			end	
+		end
+		
+		# Base Dijkstra implementation 
+		def dijkstra(source)
+			@distance = {}
+			@prev = {}
+
+			@nodes.each do |i|
+				@distance[i] = @INFINITY
+				@prev[i] = -1
+			end	
+
+			@distance[source] = 0
+			q = @nodes.compact
+			@modifier = 0;
+			while q.size > 0
+				u = nil;
+				
+				q.each do |min|
+					if (not u) or (@distance[min] and @distance[min] < @distance[u])
+						u = min
+					end
+				end
+
+				if (@distance[u] == @INFINITY)
+					break
+				end
+				q = q - [u]
+				@graph[u].keys.each do |v| 
+					current_line = @graph[u][v][1]
+					modifier = 0 # setting station change modifier to a default 0
+					if @distance[u] > 0 
+						modifier = changed_line?(@prev[u][1], current_line) == true ? 1 : 0
+					end
+					alt = @distance[u] + @graph[u][v][0] + modifier
+					
+					if(alt < @distance[v])
+						@distance[v] = alt
+						@prev[v] = [u, current_line]
+ 					end
+				end
+			end
+		end
+
+		# Helper method to check if there is a possible line change between station
+		def changed_line?(previous_line, current_line)
+			previous_line.each do |line|
+				if current_line.include?(line)
+					return false
+				end
+			end
+			return true
+		end
+		
+		# print path method
+		def print_path(dest)
+			if @prev[dest] != -1
+				print_path @prev[dest][0]
+			end
+			@tube_list << dest
+		end
+	
+
+		def load_from_yaml
+			lines = YAML.load_file(File.join(File.dirname(File.expand_path(__FILE__)), "../assets/tube_list.yml"))
+			lines.each do |line|
+				stations = line[1]
+				stations.each_with_index do |station,index|
+					add_edge(station.keys[0], station.values[0], 1, line[0])
+				end
+			end
+		end
+		
+		# Gets all shortests paths using dijkstra
+		def shortest_paths(source, dest)
+			@source = source
+			dijkstra source
+			print_path dest
+			return @distance[dest]
+		end
+
+
+		def print_shortest_paths(source,dest, web_request)
+			check_data_integrity(source, dest)
+			total_distance = shortest_paths(source, dest)
+			stations_changed = (total_distance - @tube_list.size) > 0 ? (total_distance - @tube_list.size) : 0;
+			if total_distance != @INFINITY
+				if !web_request
+					puts "#{@tube_list.join(', ')}"
+					puts "\nDistance: #{total_distance}, you changed station #{stations_changed} times"
+				else
+					return "#{@tube_list.join(', ')}"
+				end
+			else
+				puts "NO PATH"
+			end
+		end
+
+		# Helper method to check if the stations are the correct ones
+		def check_data_integrity(source, dest)
+			station_list = @graph.map {|x| x.first}
+			errors = []
+			if !station_list.include?(source)
+				errors << source
+			end
+
+			if !station_list.include?(dest)
+				errors << dest
+			end
+
+			if errors.size > 0
+				puts "The following stations were not found in the application: #{errors.join(",")}. Please, check your data."
+				exit
+			end
+		end
+	end
+end

data/lib/undergrounder/tube_scraper.rb

@@ -0,0 +1,52 @@
+require 'rubygems'
+require 'mechanize'
+require 'yaml'
+
+module TubeScraper
+	def self.start!
+		@agent = Mechanize.new
+		@agent.get('http://tubephotos.dannycox.me.uk/stationsbyline.html'); # page fetching
+		tube_name_list, final_list = [], []
+		@agent.page.search('.style5').each {|x| tube_name_list << x.first[1]} # we search through all the occurrence of the class that holds station names..
+		tube_name_list.uniq!.sort! #then tidy up the array and sort alphabetically
+
+		stations = @agent.page.search('.stationList')
+		stations.each do |element|
+			children = element.elements.children;
+			temp_tube_list, temp_list = [], []
+			children.each_with_index do |x, i| # for every station object we..
+				value = x.text.split("\n").join(" ") # ..remove carriages inside the name.
+					.gsub("  "," ") # ...remove double unaestetic double spaces
+					.gsub("&", "and") # ...change the & to and, to better hand data in yaml
+					.gsub(/\(([^\)]+)\)/,'').rstrip # ...remove everything is between parentheses. 
+				if(value != "")
+					temp_list << value
+				end
+			end 
+
+			# Having obtained a clear list of the tube stations, we create
+			# a series of { source => target } hashes
+			temp_list.each_with_index do |prov,index| 
+				if index + 1 < temp_list.size
+					temp_tube_list << { prov => temp_list[index+1] }
+				end
+			end
+
+
+			final_list << temp_tube_list if temp_tube_list.size > 0
+
+		end
+
+		# Once we have all the station connections, we push the line name
+		# at the beginning of every array.
+		final_list.each_with_index do |lines,index|
+			lines.unshift(tube_name_list[index].gsub("&","and"))
+		end
+
+		#and we finally save it!
+		File.open(Dir.pwd + "/tube_list2.yml", 'w+') {|f| f.write(final_list.to_yaml) }
+	end
+
+end
+
+

data/lib/undergrounder/version.rb

@@ -0,0 +1,3 @@
+module Undergrounder
+  VERSION = "0.1.0"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'undergrounder'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+end

data/spec/undergrounder_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+describe Undergrounder do
+	  describe "Test" do
+	  	before(:each) do
+	  	  	@graph = Undergrounder::Graph.new
+	  	  	@graph.load_from_yaml
+	  	end
+
+		describe "data integrity" do
+			it "should detect if the source is wrong" do
+			  STDOUT.should_receive(:puts).with("The following stations were not found in the application: Lappland. Please, check your data.")
+		  	  expect { @graph.print_shortest_paths("Lappland", "Hammersmith", false) }.to raise_exception SystemExit
+			end
+		  
+		  	it "should detect if the destination is wrong" do
+			  STDOUT.should_receive(:puts).with("The following stations were not found in the application: Santa Claws. Please, check your data.")
+		  	  expect { @graph.print_shortest_paths("Hammersmith", "Santa Claws", false) }.to raise_exception SystemExit
+			end
+
+			it "should detect if both source and destionation are wrong" do
+			  STDOUT.should_receive(:puts).with("The following stations were not found in the application: Lappland,Santa Claws. Please, check your data.")
+		  	  expect { @graph.print_shortest_paths("Lappland", "Santa Claws", false) }.to raise_exception SystemExit
+			end
+		end
+
+		describe "Shortest paths correctness" do
+			it "should find that the right weight from Brixton to Liverpool Street is 9" do
+			  @graph.shortest_paths("Brixton", "Liverpool Street").should == 9
+			end
+
+			it "should work the same inverting source and destination" do
+			  @graph.shortest_paths("Liverpool Street", "Brixton").should == 9
+			end
+
+
+			describe "Various tests about different distance correctness" do
+
+				#Simple test with no line changing
+			    it "Euston, Goodge Street" do
+			      @graph.shortest_paths("Euston", "Goodge Street").should == 2
+			    end
+
+			    # Graphically, Euston/Warren Street/Oxford Circus/Tottenham has the same weight of Euston/Warren Street/Goodge Street/Tottenham.
+			    # But the latter has no station change, so it is preferrable over the first
+			    it "Euston, Tottenham Court Road" do
+			      @graph.shortest_paths("Euston", "Tottenham Court Road").should == 3
+			    end
+
+			    # This is tricky. Euston/Embankment on the northern is 6, Via Victoria/Bakerloo is 5 + 1 line change.
+			    it "Euston, Embankment" do
+			      @graph.shortest_paths("Euston", "Embankment").should == 6
+			    end
+
+			    # One line change. The algorithm prefer to use the metropolitan line, who has less stations between W. Park and B. Street
+			    it "Stanmore, Baker Street" do
+			      @graph.shortest_paths("Stanmore", "Baker Street").should == 7
+			    end
+
+			    # 2 line change - Circle(or Metropolitan or Hammersmith) + Victoria + Piccadilly
+			    it "Euston Square, Manor House" do
+			      @graph.shortest_paths("Euston Square", "Manor House").should == 6
+			    end
+
+			    # Starting from a station with 2 lines, finishing with a station with one line.
+			    it "Bow Road, Upminster" do
+			      @graph.shortest_paths("Bow Road", "Upminster").should == 14
+			    end
+
+			    it "Piccadilly Circus, Westminster" do
+			      @graph.shortest_paths("Piccadilly Circus", "Westminster").should == 3
+			    end
+
+			    # This test fail. Really i'm not understanding why. Basically is not counting the station change :-/
+			    # it "Stanmore, Sudbury Town" do
+			    #   @graph.shortest_paths("Stanmore", "Sudbury Town").should == 14
+			    # end
+			end
+		end
+		
+
+		describe "Print shortest paths correctness" do
+		  	it "should print the correct path from Livepool Street to Brixton" do
+	  		  output = capture_stdout { @graph.print_shortest_paths("Brixton", "Liverpool Street", false) }
+	  		  output.should include("Brixton, Stockwell, Oval, Kennington, Waterloo, Bank, Liverpool Street")
+		  	end
+
+		  	it "should print the correct path from Bow Road to Upminster" do
+	  		  output = capture_stdout { @graph.print_shortest_paths("Bow Road", "Upminster", false) }
+	  		  output.should include("Bow Road, Bromley-by-Bow, West Ham, Plaistow, Upton Park, East Ham, Barking, Upney, Becontree, Dagenham Heathway, Dagenham East, Elm Park, Hornchurch, Upminster Bridge, Upminster")
+		  	end
+
+		  	it "should print the correct path from Stratford to Limehouse" do
+		  		# Looking at the map you'd think that taking the Jubilee will be fastest...
+		  		output = capture_stdout { @graph.print_shortest_paths("Stratford", "Limehouse", false) }
+	  		  	output.should include("Stratford, Mile End, Bethnal Green, Liverpool Street, Bank, Shadwell, Limehouse")
+		  	end
+
+		end
+
+
+		# Helper method to search through the STDOUT 
+		def capture_stdout(&block)
+		  original_stdout = $stdout
+		  $stdout = fake = StringIO.new
+		  begin
+		    yield
+		  ensure
+		    $stdout = original_stdout
+		  end
+		  fake.string
+		end
+
+	end
+end

data/undergrounder.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'undergrounder/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "undergrounder"
+  gem.version       = Undergrounder::VERSION
+  gem.authors       = ["Enzo Rivello"]
+  gem.email         = ["vincenzo.rivello@gmail.com"]
+  gem.description   = "Simple Implementation of a short path finder for the London Tube"
+  gem.summary       = ""
+  gem.homepage      = "https://github.com/enzor/undergrounder"
+
+  gem.add_dependency "sinatra"
+  gem.add_dependency "padrino"
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "ruby-debug19"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

data/vendor/web_finder/.components

@@ -0,0 +1,9 @@
+---
+:orm: activerecord
+:test: none
+:mock: none
+:script: none
+:renderer: slim
+:stylesheet: none
+:namespace: WebFinder
+:migration_format: number

data/vendor/web_finder/.gitignore

@@ -0,0 +1,8 @@
+.DS_Store
+log/**/*
+tmp/**/*
+bin/*
+vendor/gems/*
+!vendor/gems/cache/
+.sass-cache/*
+db/*.db

data/vendor/web_finder/Gemfile

@@ -0,0 +1,37 @@
+source 'https://rubygems.org'
+
+# Distribute your app as a gem
+# gemspec
+
+# Server requirements
+# gem 'thin' # or mongrel
+# gem 'trinidad', :platform => 'jruby'
+
+# Optional JSON codec (faster performance)
+# gem 'oj'
+
+# Project requirements
+gem 'rake'
+
+# Component requirements
+gem 'slim'
+gem 'activerecord', '>= 3.1', :require => 'active_record'
+gem 'sqlite3'
+
+# Test requirements
+
+# Padrino Stable Gem
+gem 'tilt', '1.3.7'
+gem 'padrino', '0.11.1'
+gem 'undergrounder'
+gem 'ruby-debug19'
+gem 'haml'
+
+
+# Or Padrino Edge
+# gem 'padrino', :github => 'padrino/padrino-framework'
+
+# Or Individual Gems
+# %w(core gen helpers cache mailer admin).each do |g|
+#   gem 'padrino-' + g, '0.11.1'
+# end