active_road 0.0.2

data/.gitignore

@@ -0,0 +1,9 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+*~
+coverage/*
+log/*
+spec/dummy/log/*.log
+*.swp

data/.rvmrc

@@ -0,0 +1 @@
+rvm ruby-1.9.3-head

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+rvm:
+  - 1.9.3
+env:
+  - POSTGIS=1.5
+before_install: ./travis/before_install.sh
+before_script: 
+  - ./travis/before_script.sh
+  - "rake ci:prepare"
+  - "rake db:create"
+script: "rake ci:build"

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in activeroad.gemspec
+gemspec
+
+gem 'dr-postgis_adapter', :require => "postgis_adapter"
+
+group :development do
+  gem 'rails-erd'
+  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

data/Guardfile

@@ -0,0 +1,26 @@
+guard 'bundler' do
+  watch('Gemfile')
+end
+
+guard 'rspec', :version => 2, :notification => false, :bundler => true, :binstubs => false do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # Rails example
+  watch(%r{^lib/(.+)\.rb$})                           { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch(%r{^lib/active_road/(.+)\.rb$})                { |m| "spec/lib/active_road/#{m[1]}_spec.rb" }
+  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^app/(.*)(\.erb|\.haml)$})                 { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  watch('config/routes.rb')                           { "spec/routing" }
+  watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+  # Capybara request specs
+  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/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2010-2013 Cityway, inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,37 @@
+# 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)
+
+Rails engine with a model for roads and rails description
+
+Requirements
+------------
+ 
+This code has been run and tested on Ruby 1.9.3
+
+Installation
+------------
+ 
+This package is available in RubyGems and can be installed with:
+ 
+   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).
+
+Example Usage 
+------------
+
+...
+
+License
+-------
+ 
+This project is licensed under the MIT license, a copy of which can be found in the LICENSE file.
+
+
+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.

data/Rakefile

@@ -0,0 +1,46 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+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
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ActiveRoad'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+RSpec::Core::RakeTask.new(:rcov) do |t|
+  t.rcov = true
+  t.rcov_opts = %w{--exclude osx\/objc,gems\/,spec\/,lib\/database_cleaner\/}
+end
+
+task :spec => "app:db:test:prepare"

data/active_road.gemspec

@@ -0,0 +1,38 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "active_road/version"
+
+Gem::Specification.new do |s|
+  s.name        = "active_road"
+  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.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  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_dependency 'activerecord'
+  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 'nokogiri'
+  s.add_dependency 'saxerator'
+  s.add_dependency 'shortest_path', '0.0.3'
+  s.add_dependency 'enumerize', '0.6.1'
+end

data/app/models/active_road/access_link.rb

@@ -0,0 +1,44 @@
+class ActiveRoad::AccessLink
+
+  attr_accessor :departure, :arrival
+
+  def initialize(attributes = {})
+    attributes.each do |k, v|
+      send("#{k}=", v)
+    end
+  end
+
+  def name
+    "AccessLink : #{departure} -> #{arrival}"
+  end
+
+  alias_method :to_s, :name
+
+  def self.from(location, constraints = {})
+    ActiveRoad::AccessPoint.from(location, constraints).collect do |access_point|
+      new :departure => location, :arrival => access_point
+    end
+  end
+
+  def length
+    @length ||= departure.to_geometry.spherical_distance arrival.to_geometry
+  end
+  # TODO Delete this hack due to postgis adapter in physical road
+  alias_method :length_in_meter, :length 
+
+  def geometry
+    @geometry ||= GeoRuby::SimpleFeatures::LineString.from_points [departure.to_geometry, arrival.to_geometry]
+  end
+  alias_method :to_geometry, :geometry
+
+  delegate :access_to_road?, :to => :arrival
+
+  def paths(constraints = {})
+    arrival.respond_to?(:paths) ? arrival.paths(constraints) : [arrival]
+  end
+
+  def access_to_road?(road)
+    arrival.respond_to?(:access_to_road?) ? arrival.access_to_road?(road) : false
+  end
+
+end

data/app/models/active_road/access_point.rb

@@ -0,0 +1,65 @@
+# Access Point is a projection from an origin point on a Physical Road
+# This origin point and Access Point are linked by an Access Link  
+
+class ActiveRoad::AccessPoint
+
+  attr_accessor :location, :physical_road, :exit
+  alias_method :exit?, :exit
+
+  def initialize(attributes = {})
+    attributes.each do |k, v|
+      send("#{k}=", v)
+    end
+  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|
+      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|
+      new :location => location, :physical_road => physical_road, :exit => true
+    end
+  end
+
+  def location_on_road(road = nil)
+    @location_on_road ||= physical_road.locate_point location
+  end
+
+  def point_on_road
+    @point_on_road ||= physical_road.interpolate_point location_on_road
+  end
+  alias_method :to_geometry, :point_on_road
+  alias_method :geometry, :point_on_road
+
+  def access_to_road?(road)
+    physical_road == road
+  end
+
+  def name
+    "Access on #{physical_road.objectid} @#{point_on_road.to_lat_lng} (for @#{location.to_lat_lng})"
+  end
+
+  delegate :spherical_distance, :to => :point_on_road
+
+  def to_s
+    name
+  end
+
+  def paths(constraints = {})
+    unless exit?
+      ActiveRoad::Path.all self, physical_road.junctions, physical_road
+    else
+      [ActiveRoad::AccessLink.new(:departure => self, :arrival => location)]
+    end
+  end
+
+end

data/app/models/active_road/base.rb

@@ -0,0 +1,5 @@
+class ActiveRoad::Base < ActiveRecord::Base
+  self.abstract_class = true
+
+  establish_connection :roads if configurations["roads"].present?
+end

data/app/models/active_road/junction.rb

@@ -0,0 +1,52 @@
+# 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
+    attr_accessible :objectid, :tags, :geometry, :height, :waiting_constraint
+
+    validates_uniqueness_of :objectid
+
+    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|
+        ActiveRoad::Path.all self, (physical_road.junctions - [self]), physical_road
+      end.flatten
+    end
+
+    def access_to_road?(road)
+      physical_roads.include? road
+    end
+
+    def to_geometry
+      geometry
+    end
+
+    def to_s
+      "Junction @#{geometry.to_lat_lng}"
+    end
+
+    def name
+      physical_roads.join(" - ")
+    end
+  end
+end

data/app/models/active_road/junction_conditionnal_cost.rb

@@ -0,0 +1,13 @@
+module ActiveRoad
+  class JunctionConditionnalCost < ActiveRoad::Base
+
+    belongs_to :junction
+    belongs_to :start_physical_road, :class_name => 'ActiveRoad::PhysicalRoad', :foreign_key => 'start_physical_road_id'
+    belongs_to :end_physical_road, :class_name => 'ActiveRoad::PhysicalRoad', :foreign_key => 'end_physical_road_id'
+
+    validates_presence_of :junction_id
+    validates_presence_of :tags
+    validates_presence_of :cost
+    
+  end
+end

data/app/models/active_road/logical_road.rb

@@ -0,0 +1,41 @@
+module ActiveRoad
+  class LogicalRoad < ActiveRoad::Base
+    extend ActiveSupport::Memoizable
+    attr_accessible :objectid, :name
+
+    validates_uniqueness_of :objectid
+
+    has_many :physical_roads, :class_name => "ActiveRoad::PhysicalRoad", :inverse_of => :logical_road
+
+    has_many :numbers, :through => :physical_roads, :class_name => "ActiveRoad::StreetNumber"
+
+    def geometry
+      GeoRuby::SimpleFeatures::MultiLineString.from_line_strings physical_roads.map(&:geometry)
+    end
+
+    def at(value)
+      if Float === value
+        geometry_at_location value
+      else
+        geometry_at_number value
+      end
+    end
+
+    def geometry_at_number(number)
+      numbers.find_or_initialize_by_number(number.to_s).tap do |number|
+        number.road = self
+      end.geometry if number.present?
+    end
+    memoize :geometry_at_number
+
+    def geometry_at_location(location)
+      geometry.interpolate_point(location) if geometry
+    end
+
+    def self.find_all_by_bounds(bounds)
+      ne_corner, sw_corner = bounds.upper_corner, bounds.lower_corner
+      sql_box = "SetSRID('BOX3D(#{ne_corner.lng} #{ne_corner.lat}, #{sw_corner.lng} #{sw_corner.lat})'::box3d, #{ActiveRoad.srid})"
+      find :all, :conditions => "geometry && #{sql_box}"
+    end
+  end
+end