active_road 0.0.2 → 0.0.3

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YWZlZDYwNDEyOGU0Yjk4OGU5NDU1ZmMxYjA4ZmIzNjk4ODAwZjMxOA==
+  data.tar.gz: !binary |-
+    MjA5NTk3MTgzMDk1MWJkNWQ3YzNjYzEyMTA3YzZhMGI5YTM1ZDkyOA==
+SHA512:
+  metadata.gz: !binary |-
+    ZDUxMTViZDcyNGFhZGZkN2JlYjAzMjQ3ZWU0NzI5NWRkZjY5Yzg1M2FlZjQ3
+    ZWNlNzg1OGFmYWNjZWZiOThiYjIyYWZlYzVhODFlNDUzZjIyZDMzNmY1NjQx
+    MjA4NWFhYjZiZjVlZGM3NjVhOWU1ZWFhNDBkZTk2YmM3YTNmNWQ=
+  data.tar.gz: !binary |-
+    YzIyYWIyYjY1ZjM2Yjc3NTkyM2ZhODBkYzRkZGFhYzgxYTZhNzQzNjM3Y2M5
+    MDgwZDNhMTczZDQ0OWI4MDBmMDQyZGE4MjZhMmU2ODMwNDIzMmNjYWNjMjJk
+    OTY3MzZkMDI1YTVkZWNhN2IxMTQ5ODIxZGRlZDI4Njc3YmVkOGE=

data/.rspec

@@ -0,0 +1 @@
+--colour

data/.travis.yml

@@ -1,8 +1,13 @@
 language: ruby
+addons:
+  postgresql: "9.2"
 rvm:
   - 1.9.3
-env:
-  - POSTGIS=1.5
+  - 2.0
+notifications:
+  recipients:
+    - mflorisson@cityway.fr
+    - ldonnet@cityway.fr
 before_install: ./travis/before_install.sh
 before_script: 
   - ./travis/before_script.sh

data/Gemfile

@@ -3,12 +3,18 @@ source "http://rubygems.org"
 # Specify your gem's dependencies in activeroad.gemspec
 gemspec
 
-gem 'dr-postgis_adapter', :require => "postgis_adapter"
+gem 'dr-postgis_adapter', :require => 'postgis_adapter'
+gem 'coveralls', require: false
 
 group :development do
-  gem 'rails-erd'
+  gem "rails-erd" # Tool to make schema class
   group :linux do
     gem 'rb-inotify', :require => RUBY_PLATFORM.include?('linux') && 'rb-inotify'
     gem 'rb-fsevent', :require => RUBY_PLATFORM.include?('darwin') && 'rb-fsevent'
   end
 end
+
+group :development, :test do
+  gem "ruby-prof"
+  gem "bullet"
+end

data/Guardfile

@@ -2,8 +2,9 @@ guard 'bundler' do
   watch('Gemfile')
 end
 
-guard 'rspec', :version => 2, :notification => false, :bundler => true, :binstubs => false do
+guard 'rspec', :notification => false do
   watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
   watch('spec/spec_helper.rb')  { "spec" }
 
   # Rails example
@@ -19,8 +20,3 @@ guard 'rspec', :version => 2, :notification => false, :bundler => true, :binstub
   watch(%r{^app/views/(.+)/.*\.(erb|haml)$})          { |m| "spec/requests/#{m[1]}_spec.rb" }
 end
 
-guard 'migrate' do
-  watch(%r{^db/migrate/(\d+).+\.rb})
-  watch('db/seeds.rb')
-end
-

data/README.md

@@ -1,29 +1,89 @@
-# ActiveRoad [![Build Status](https://travis-ci.org/dryade/activeroad.png)](http://travis-ci.org/dryade/activeroad?branch=master) [![Dependency Status](https://gemnasium.com/dryade/activeroad.png)](https://gemnasium.com/dryade/activeroad) [![Code Climate](https://codeclimate.com/github/dryade/activeroad.png)](https://codeclimate.com/github/dryade/activeroad)
+# ActiveRoad
+[![Build Status](https://travis-ci.org/cityway-transdev/activeroad.png)](http://travis-ci.org/cityway-transdev/activeroad?branch=master) [![Dependency Status](https://gemnasium.com/cityway-transdev/activeroad.png)](https://gemnasium.com/cityway-transdev/activeroad) [![Code Climate](https://codeclimate.com/github/cityway-transdev/activeroad.png)](https://codeclimate.com/github/cityway-transdev/activeroad) [![Coverage Status](https://img.shields.io/coveralls/cityway-transdev/activeroad.svg)](https://coveralls.io/r/cityway-transdev/activeroad?branch=master)
 
-Rails engine with a model for roads and rails description
+ActiveRoads is a rails engine with a specific models for transport networks. It allows to : 
+ - import osm ways form openstreetmap datas (PBF file format)             
+ - make an itinerary research
+The goal of this project is not to make the faster itinerary search engine like [OSRM](http://map.project-osrm.org/) or [OpenTripPlanner](http://www.opentripplanner.org/) but the more flexible because it doesn't need to binarize datas.    
 
 Requirements
 ------------
  
-This code has been run and tested on Ruby 1.9.3
+This code has been run and tested on :  
+* Ruby 1.9.3 and ruby 2.0
+* Postgresql 9.X
+* Postgis 2.X
+
+External Deps
+-------------
+On Debian/Ubuntu/Kubuntu OS : 
+```sh
+ sudo apt-get install git postgresql postgis build-essential ruby-dev libproj-dev libgeos-dev libffi-dev zlib1g-dev libxslt1-dev libxml2-dev libbz2-dev libleveldb-dev libsnappy-dev
+```
 
 Installation
 ------------
  
 This package is available in RubyGems and can be installed with:
- 
-   gem install active_road
+```sh 
+ gem install active_road
+```
 
 More Information
 ----------------
  
-More information can be found on the [project website on GitHub](http://github.com/dryade/activeroad). 
-There is extensive usage documentation available [on the wiki](https://github.com/dryade/activeroad/wiki).
+More information can be found on the [project website on GitHub](http://github.com/cityway-transdev/activeroad). 
+There is extensive usage documentation available [on the wiki](https://github.com/cityway-transdev/activeroad/wiki).
 
 Example Usage 
 ------------
 
-...
+### Import OSM ways
+
+```sh
+bundle exec rake "app:active_road:import:osm_pbf_data[/home/user/test.osm.pbf]"
+
+```
+
+### Itinerary research
+
+Example of basic finder : 
+
+Actually we can use only 4 transport modes : 
+* car
+* train
+* pedestrian
+* bike 
+
+```ruby
+ from = GeoRuby::SimpleFeatures::Point.from_x_y(-52.652771, 5.174379)
+ to = GeoRuby::SimpleFeatures::Point.from_x_y(-52.323182, 4.941829)
+ speed = 4 # In kilometer/hour        
+ finder = ActiveRoad::ShortestPath::Finder.new(from, to, speed).tap do |finder|
+   finder.timeout = 30.seconds
+ end
+
+ # Get geometry
+ finder.geometry
+
+ # Get steps
+ finder.paths
+```
+
+For a more complex query, you can use constraints arguments. It's an array of string which 
+describes :
+ * if we use conditionnal cost for a physical road  Ex : ["car"]
+ * if we not use a physical road because it contains a specific conditionnal cost Ex : ["~car"]
+
+```ruby
+ from = GeoRuby::SimpleFeatures::Point.from_x_y(-52.652771, 5.174379)
+ to = GeoRuby::SimpleFeatures::Point.from_x_y(-52.323182, 4.941829)
+ speed = 50 # In kilometer/hour        
+ constraints = ["car"]
+ finder = ActiveRoad::ShortestPath::Finder.new(from, to, speed, constraints).tap do |finder|
+   finder.timeout = 30.seconds
+ end
+```
 
 License
 -------
@@ -34,4 +94,4 @@ This project is licensed under the MIT license, a copy of which can be found in
 Support
 -------
  
-Users looking for support should file an issue on the GitHub issue tracking page (https://github.com/dryade/activeroad/issues), or file a pull request (https://github.com/dryade/activeroad/pulls) if you have a fix available.
+Users looking for support should file an issue on the GitHub issue tracking page (https://github.com/cityway-transdev/activeroad/issues), or file a pull request (https://github.com/cityway-transdev/activeroad/pulls) if you have a fix available.

data/Rakefile

@@ -5,13 +5,6 @@ rescue LoadError
   puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
 end
 
-namespace :ci do
-  task :prepare do
-    cp "config/database.yml.ci", "config/database.yml"
-  end
-  task :build => ["db:migrate", "spec"]
-end
-
 begin
   require 'rdoc/task'
 rescue LoadError
@@ -44,3 +37,11 @@ RSpec::Core::RakeTask.new(:rcov) do |t|
 end
 
 task :spec => "app:db:test:prepare"
+
+namespace :ci do
+  task :prepare do
+    cp "config/database.yml.ci", "config/database.yml"
+  end
+  task :build => ["db:migrate", "spec"]
+end
+

data/active_road.gemspec

@@ -7,9 +7,12 @@ Gem::Specification.new do |s|
   s.version     = ActiveRoad::VERSION
   s.authors     = ["Alban Peignier", "Luc Donnet", "Marc Florisson"]
   s.email       = ["alban@tryphon.eu", "luc.donnet@free.fr", "mflorisson@gmail.com"]
-  s.homepage    = ""
-  s.summary     = %q{Rails engine to manage roads and rails model}
-  s.description = %q{Find street numbers and road ways}
+  s.homepage    = "https://rubygems.org/gems/active_road"
+  s.summary     = %q{Rails engine to import openstreetmap datas and make an itinerary research}
+  s.description = %q{Import openstreetmap datas and make an itinerary research}
+  s.required_ruby_version = '>= 1.9.3'
+  s.license = 'MIT'
+  #spec.requirements << 'libsnappy-dev, v6.0'
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
@@ -19,20 +22,21 @@ Gem::Specification.new do |s|
   s.add_development_dependency "guard"
   s.add_development_dependency "guard-bundler"
   s.add_development_dependency "guard-rspec"
-  s.add_development_dependency "guard-migrate"
-  s.add_development_dependency "factory_girl_rails", "~> 4.2.1"
-  s.add_development_dependency "rspec-rails", "~> 2.11.4"
-  s.add_development_dependency 'rails', '~> 3.2.13'
+  s.add_development_dependency "factory_girl_rails", ">= 4.2.1"
+  s.add_development_dependency "rspec-rails", '~> 3.1.0'
+  s.add_development_dependency 'rails', '>=3.1.12'
 
-  s.add_dependency 'activerecord'
+  s.add_dependency 'activerecord', '3.2.18'
   s.add_dependency 'activerecord-postgres-hstore'
-  s.add_dependency 'dr-postgis_adapter', '0.8.1'
-  s.add_dependency 'sqlite3', '~> 1.3.7' 
-  s.add_dependency 'pg', '~> 0.15.1' 
-  s.add_dependency 'activerecord-import', '~> 0.3.1'
-  s.add_dependency 'georuby-ext', "0.0.2"  
+  s.add_dependency 'dr-postgis_adapter', '0.8.4'
+  s.add_dependency 'pg', '>= 0.15.1'
+  s.add_dependency 'georuby-ext', "0.0.5"
   s.add_dependency 'nokogiri'
   s.add_dependency 'saxerator'
-  s.add_dependency 'shortest_path', '0.0.3'
-  s.add_dependency 'enumerize', '0.6.1'
+  s.add_dependency 'shortest_path', '0.0.4'
+  s.add_dependency 'enumerize', '0.7.0'
+  s.add_dependency "pbf_parser", '~> 0.0.6'
+  s.add_dependency "leveldb-native", '~> 0.6'
+  s.add_dependency "snappy"
+  s.add_dependency 'postgres-copy', '~> 0.6.O'
 end

data/app/models/active_road/access_link.rb

@@ -14,8 +14,8 @@ class ActiveRoad::AccessLink
 
   alias_method :to_s, :name
 
-  def self.from(location, constraints = {})
-    ActiveRoad::AccessPoint.from(location, constraints).collect do |access_point|
+  def self.from(location)
+    ActiveRoad::AccessPoint.from(location).collect do |access_point|
       new :departure => location, :arrival => access_point
     end
   end
@@ -33,8 +33,8 @@ class ActiveRoad::AccessLink
 
   delegate :access_to_road?, :to => :arrival
 
-  def paths(constraints = {})
-    arrival.respond_to?(:paths) ? arrival.paths(constraints) : [arrival]
+  def paths
+    arrival.respond_to?(:paths) ? arrival.paths : [arrival]
   end
 
   def access_to_road?(road)

data/app/models/active_road/access_point.rb

@@ -13,19 +13,15 @@ class ActiveRoad::AccessPoint
   end
 
   # Find access points from a location
-  def self.from(location, constraints = {})
-    physical_roads_filtered = ActiveRoad::PhysicalRoadFilter.new(constraints).filter
-
-    physical_roads_filtered.nearest_to(location, 100).collect do |physical_road|
+  def self.from(location)
+    ActiveRoad::PhysicalRoad.nearest_to(location).collect do |physical_road|
       new :location => location, :physical_road => physical_road
     end
   end
   
   # Find access points to go to a location
-  def self.to(location, constraints = {})
-    physical_roads_filtered = ActiveRoad::PhysicalRoadFilter.new(constraints).filter
-    
-    physical_roads_filtered.nearest_to(location, 100).collect do |physical_road|
+  def self.to(location)   
+    ActiveRoad::PhysicalRoad.nearest_to(location).collect do |physical_road|
       new :location => location, :physical_road => physical_road, :exit => true
     end
   end
@@ -41,7 +37,7 @@ class ActiveRoad::AccessPoint
   alias_method :geometry, :point_on_road
 
   def access_to_road?(road)
-    physical_road == road
+    physical_road.id == road.id
   end
 
   def name

data/app/models/active_road/boundary.rb

@@ -0,0 +1,41 @@
+module ActiveRoad
+  class Boundary < ActiveRoad::Base
+    #set_table_name :boundaries
+    attr_accessible :objectid, :geometry, :name, :admin_level, :postal_code, :insee_code
+    acts_as_geom :geometry => :multi_polygon
+
+    # Return linear rings which delimit multi polygon area 
+    def self.all_uniq_borders
+      borders = self.all.collect(&:geometry).collect(&:polygons).flatten(1).collect(&:rings).flatten(1).uniq
+      GeoRuby::SimpleFeatures::MultiLineString.from_line_strings(borders)
+    end
+    
+    # Return linear rings which delimit multi polygon area 
+    def borders
+      geometry.polygons.collect(&:rings).flatten
+    end
+    
+    def intersection(other)
+      postgis_calculate(:intersection, [self, other])
+    end
+
+    
+    def difference(other)
+      postgis_calculate(:difference, [self, other])
+    end
+
+    def sym_difference(other)
+      postgis_calculate(:symDifference, [self, other])
+    end    
+    
+    # Contains not take object equals on a boundary border!!
+    def self.first_contains(other)
+      where("ST_Contains(geometry, ST_GeomFromEWKT(E'#{other.as_hex_ewkb}'))").first
+    end
+
+    def self.all_intersect(other)
+      where("ST_Intersects(geometry, ST_GeomFromEWKT(E'#{other.as_hex_ewkb}'))")
+    end
+    
+  end  
+end

data/app/models/active_road/junction.rb

@@ -1,6 +1,4 @@
 # A junction is a connection between 1 to n physical roads
-require "activerecord-postgres-hstore"
-
 module ActiveRoad
   class Junction < ActiveRoad::Base
     serialize :tags, ActiveRecord::Coders::Hstore
@@ -11,30 +9,18 @@ module ActiveRoad
     has_and_belongs_to_many :physical_roads, :class_name => "ActiveRoad::PhysicalRoad",:uniq => true
     has_many :junction_conditionnal_costs, :class_name => "ActiveRoad::JunctionConditionnalCost"
 
-    %w[max_speed, max_slope].each do |key|
-      attr_accessible key
-      scope "has_#{key}", lambda { |value| where("properties @> hstore(?, ?)", key, value) }      
-      define_method(key) do
-        properties && properties[key]
-      end
-      
-      define_method("#{key}=") do |value|
-        self.properties = (properties || {}).merge(key => value)
-      end
-    end
-
     def location_on_road(road)
       (@location_on_road ||= {})[road.id] ||= road.locate_point(geometry)
     end
 
-    def paths(tags = {})
-      ActiveRoad::PhysicalRoadFilter.new(tags, physical_roads).filter.includes(:junctions).collect do |physical_road|
+    def paths
+      physical_roads.includes(:junctions, :physical_road_conditionnal_costs).collect do |physical_road|
         ActiveRoad::Path.all self, (physical_road.junctions - [self]), physical_road
       end.flatten
     end
 
     def access_to_road?(road)
-      physical_roads.include? road
+      physical_roads.pluck(:id).include? road.id
     end
 
     def to_geometry
@@ -42,7 +28,7 @@ module ActiveRoad
     end
 
     def to_s
-      "Junction @#{geometry.to_lat_lng}"
+      "Junction @#{geometry.lng},#{geometry.lat}"
     end
 
     def name

data/app/models/active_road/junction_conditionnal_cost.rb

@@ -1,5 +1,6 @@
 module ActiveRoad
   class JunctionConditionnalCost < ActiveRoad::Base
+    attr_accessible :tags, :cost, :start_physical_road, :end_physical_road
 
     belongs_to :junction
     belongs_to :start_physical_road, :class_name => 'ActiveRoad::PhysicalRoad', :foreign_key => 'start_physical_road_id'
@@ -7,6 +8,7 @@ module ActiveRoad
 
     validates_presence_of :junction_id
     validates_presence_of :tags
+    validates_uniqueness_of :tags
     validates_presence_of :cost
     
   end

data/app/models/active_road/junctions_physical_road.rb

@@ -0,0 +1,5 @@
+module ActiveRoad
+  class JunctionsPhysicalRoad < ActiveRoad::Base
+
+  end
+end

data/app/models/active_road/logical_road.rb

@@ -1,13 +1,14 @@
 module ActiveRoad
   class LogicalRoad < ActiveRoad::Base
     extend ActiveSupport::Memoizable
-    attr_accessible :objectid, :name
-
-    validates_uniqueness_of :objectid
+    attr_accessible :objectid, :name, :boundary_id
 
     has_many :physical_roads, :class_name => "ActiveRoad::PhysicalRoad", :inverse_of => :logical_road
-
     has_many :numbers, :through => :physical_roads, :class_name => "ActiveRoad::StreetNumber"
+    belongs_to :boundary, :class_name => "ActiveRoad::Boundary"
+
+    #validates_uniqueness_of :objectid
+    #validates :boundary, presence: true
 
     def geometry
       GeoRuby::SimpleFeatures::MultiLineString.from_line_strings physical_roads.map(&:geometry)

data/app/models/active_road/osm_pbf_importer.rb

@@ -0,0 +1,293 @@
+module ActiveRoad
+  module OsmPbfImporter
+
+    @@relation_required_tags_keys = ["boundary", "admin_level"]
+    @@relation_selected_tags_keys = ["boundary", "admin_level", "ref:INSEE", "name", "addr:postcode", "type"]
+    mattr_reader :relation_required_tags_keys
+    mattr_reader :relation_selected_tags_keys    
+
+    @@way_required_tags_keys = ["highway", "railway", "boundary", "admin_level", "addr:housenumber"]
+    @@way_for_physical_road_required_tags_keys = ["highway", "railway"]
+    @@way_for_boundary_required_tags_keys = ["boundary", "admin_level"]
+    @@way_for_street_number_required_tags_keys = ["addr:housenumber"]
+    @@way_selected_tags_keys = [ "name", "maxspeed", "oneway", "boundary", "admin_level", "addr:housenumber" ]
+    # Add first_node_id and last_node_id
+    @@way_optionnal_tags_keys = ["highway", "maxspeed", "bridge", "tunnel", "toll", "cycleway", "cycleway-right", "cycleway-left", "cycleway-both", "oneway:bicycle", "oneway", "bicycle", "segregated", "foot", "lanes", "lanes:forward", "lanes:forward:bus", "busway:right", "busway:left", "oneway_bus", "boundary", "admin_level", "access", "construction", "junction", "motor_vehicle", "psv", "bus", "addr:city", "addr:country", "addr:state", "addr:street"]
+    mattr_reader :way_required_tags_keys
+    mattr_reader :way_for_physical_road_required_tags_keys
+    mattr_reader :way_for_boundary_required_tags_keys
+    mattr_reader :way_for_street_number_required_tags_keys
+    mattr_reader :way_selected_tags_keys
+    mattr_reader :way_optionnal_tags_keys
+
+    @@nodes_selected_tags_keys = [ "addr:housenumber", "addr:city", "addr:postcode", "addr:street" ]
+    mattr_reader :nodes_selected_tags_keys
+
+    @@pg_batch_size = 10000 # Not Rails.logger.debug a high value because postgres failed to allocate memory
+    mattr_reader :pg_batch_size
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+    end
+
+    def pedestrian?(tags)
+      highway_tag_values = %w{pedestrian footway path steps}
+      if tags["highway"].present? && highway_tag_values.include?(tags["highway"])
+        true
+      else
+        false
+      end
+    end
+
+    # http://wiki.openstreetmap.org/wiki/FR:Cycleway
+    # http://wiki.openstreetmap.org/wiki/FR:Bicycle
+    def bike?(tags)
+      highway_tag_values = %w{cycleway}
+      bike_tags_keys = ["cycleway:left", "cycleway:right", "cycleway", "cycleway:left"]
+
+      if (tags["highway"].present? && highway_tag_values.include?(tags["highway"])) || (bike_tags_keys & tags.keys).present?
+        true
+      else
+        false
+      end
+    end
+
+    # http://wiki.openstreetmap.org/wiki/Key:railway
+    def train?(tags)
+      railway_tag_values = %w{rail tram funicular light_rail subway}
+      if tags["railway"].present? && railway_tag_values.include?(tags["railway"])
+        true
+      else
+        false
+      end
+    end
+
+    # http://wiki.openstreetmap.org/wiki/FR:France_roads_tagging
+    def car?(tags)
+      highway_tag_values = %w{motorway trunk trunk_link primary secondary tertiary motorway_link primary_link unclassified service road residential track}
+      if tags["highway"].present? && highway_tag_values.include?(tags["highway"])
+        true
+      else
+        false
+      end
+    end
+
+    def required_way?(required_tags, tags)
+      required_tags.each do |require_tag_key|
+        if tags.keys.include?(require_tag_key)
+          return true
+        end
+      end
+      return false
+    end
+
+    def required_relation?(tags)
+      @@relation_required_tags_keys.each do |require_tag_key|
+        if tags.keys.include?(require_tag_key)
+          return true
+        end
+      end
+      return false
+    end
+
+    # Return an hash with tag_key => tag_value for osm attributes
+    def selected_tags(tags, selected_tags_keys)
+      {}.tap do |selected_tags|
+        tags.each do |key, value|
+          if selected_tags_keys.include?(key)
+            selected_tags[key] = value
+          end
+        end           
+      end
+    end
+
+    # def extract_tag_value(tag_value)
+    #   case tag_value 
+    #   when "yes" : 1 
+    #   when "no" : 0
+    #   when /[0-9].+/i tag_value.to_f        
+    #   else 0    
+    #   end     
+    # end
+
+    def physical_road_conditionnal_costs(way)
+      [].tap do |prcc|        
+        prcc << [ "car", Float::MAX] if !way.car
+        prcc << [ "pedestrian", Float::MAX] if !way.pedestrian
+        prcc << [ "bike", Float::MAX] if !way.bike
+        prcc << [ "train", Float::MAX] if !way.train
+      end
+    end            
+
+    def extract_relation_polygon(outer_geometries, inner_geometries = [])
+      outer_rings = join_ways(outer_geometries)
+      inner_rings = join_ways(inner_geometries)
+
+      # TODO : Fix the case where many outer rings with many inner rings
+      polygons = [].tap do |polygons|
+        outer_rings.each { |outer_ring|
+          polygons << GeoRuby::SimpleFeatures::Polygon.from_linear_rings( [outer_ring] + inner_rings )
+        }
+      end
+    end
+
+    def join_ways(ways)
+      closed_ways = []
+      endpoints_to_ways = EndpointToWayMap.new
+      for way in ways
+        if way.closed?
+          closed_ways << way
+          next
+        end
+
+        # Are there any existing ways we can join this to?
+        to_join_to = endpoints_to_ways.get_from_either_end(way)
+        if to_join_to.present?
+          joined = way
+          for existing_way in to_join_to
+            joined = join_way(joined, existing_way)
+            endpoints_to_ways.remove_way(existing_way)
+            if joined.closed?
+              closed_ways << joined
+              break
+            end
+          end
+
+          if !joined.closed?
+            endpoints_to_ways.add_way(joined)
+          end
+        else
+          endpoints_to_ways.add_way(way)
+        end
+      end
+
+      if endpoints_to_ways.number_of_endpoints != 0
+        raise StandardError, "Unclosed boundaries"
+      end
+
+      closed_ways
+    end
+
+    def join_way(way, other)
+      if way.closed?
+        raise StandardError, "Trying to join a closed way to another"
+      end
+      if other.closed?
+        raise StandardError, "Trying to join a way to a closed way"
+      end
+
+      if way.points.first == other.points.first
+        new_points = other.reverse.points[0..-2] + way.points
+      elsif way.points.first == other.points.last
+        new_points = other.points[0..-2] + way.points
+      elsif way.points.last == other.points.first
+        new_points = way.points[0..-2] + other.points
+      elsif way.points.last == other.points.last
+        new_points = way.points[0..-2] + other.reverse.points
+      else
+        raise StandardError, "Trying to join two ways with no end point in common"
+      end
+
+      GeoRuby::SimpleFeatures::LineString.from_points(new_points)
+    end
+
+    class EndpointToWayMap
+      attr_accessor :endpoints
+
+      def initialize
+        @endpoints = {}
+      end
+
+      def add_way(way)
+        if get_from_either_end(way).present?
+          raise StandardError, "Call to add_way would overwrite existing way(s)"
+        end
+        self.endpoints[way.points.first] = way
+        self.endpoints[way.points.last] = way
+      end
+
+      def remove_way(way)
+        endpoints.delete(way.points.first)
+        endpoints.delete(way.points.last)
+      end
+
+      def get_from_either_end(way)
+        [].tap do |selected_end_points|
+          selected_end_points << endpoints[way.points.first] if endpoints.include?(way.points.first)
+          selected_end_points << endpoints[way.points.last] if endpoints.include?(way.points.last)
+        end
+      end
+
+      def number_of_endpoints
+        return endpoints.size
+      end
+
+    end
+
+    class Node
+      attr_accessor :id, :lon, :lat, :ways, :end_of_way, :addr_housenumber, :tags
+
+      def initialize(id, lon, lat, addr_housenumber = "", ways = [], end_of_way = false, tags = {} )
+        @id = id
+        @lon = lon
+        @lat = lat
+        @addr_housenumber = addr_housenumber
+        @ways = ways
+        @end_of_way = end_of_way
+        @tags = tags
+      end
+
+      def add_way(id)
+        @ways << id
+      end
+
+      def marshal_dump
+        [@id, @lon, @lat, @addr_housenumber, @ways, @end_of_way, @tags]
+      end
+
+      def marshal_load array
+        @id, @lon, @lat, @addr_housenumber, @ways, @end_of_way, @tags = array
+      end
+
+      def used?
+        ( ways.present? && ways.size > 1 ) || end_of_way
+      end
+    end
+
+    class Way
+      attr_accessor :id, :nodes, :car, :bike, :train, :pedestrian, :name, :maxspeed, :oneway, :boundary, :admin_level, :addr_housenumber, :options
+
+      def initialize(id, nodes = [], car = false, bike = false, train = false, pedestrian = false, name = "", maxspeed = 0, oneway = false, boundary = "", admin_level = "", addr_housenumber = "", options = {})
+        @id = id
+        @nodes = nodes
+        @car = car
+        @bike = bike
+        @train = train
+        @pedestrian = pedestrian
+        @name = name
+        @maxspeed = maxspeed
+        @oneway = oneway
+        @boundary = boundary
+        @admin_level = admin_level
+        @addr_housenumber = addr_housenumber
+        @options = options
+      end
+
+      def add_node(id)
+        @nodes << id
+      end
+
+      def marshal_dump
+        [@id, @nodes, @car, @bike, @train, @pedestrian, @name, @maxspeed, @oneway, @boundary, @admin_level, @addr_housenumber, @options]
+      end
+
+      def marshal_load array
+        @id, @nodes, @car, @bike, @train, @pedestrian, @name, @maxspeed, @oneway, @boundary, @admin_level, @addr_housenumber, @options = array
+      end
+    end
+
+  end
+end