routing 0.0.2

data/spec/routing/adapter/test_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Routing::Adapter::Test do
+
+  context 'creating a new instance' do
+
+    it 'can be instantiated without arguments' do
+      expect { Routing::Adapter::Test.new }.to_not raise_error
+    end
+
+  end
+
+  describe '#calculate' do
+
+    let(:geo_points) { [stub(:lat => 1, :lng => 2), stub(:lat => 3, :lng => 4), stub(:lat => 5, :lng => 6)] }
+
+    it 'returns an array of geopoints with values that are passed to the method' do
+      subject.calculate(geo_points).each_with_index do |new_geo_point, index|
+        new_geo_point.lat.should eql(geo_points[index].lat)
+        new_geo_point.lng.should eql(geo_points[index].lng)
+        new_geo_point.original_lng.should eql(geo_points[index].lng)
+        new_geo_point.original_lng.should eql(geo_points[index].lng)
+        new_geo_point.should be_waypoint
+      end
+    end
+
+  end
+
+end

data/spec/routing/geo_point_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Routing::GeoPoint do
+
+  context 'creating a new instance' do
+    it 'can be instantiated without arguments' do
+      expect { described_class.new }.to_not raise_error
+    end
+
+    context 'initialized with attributes' do
+      subject { described_class.new(:lat => 1, :lng => 2) }
+
+      its(:lat) { should be(1) }
+      its(:lng) { should be(2) }
+
+      it 'ignores passed attributes that dont exist' do
+        expect { described_class.new(:hello => :world) }.to_not raise_error
+      end
+    end
+  end
+
+  [:lat, :lng, :original_lat, :original_lng, :relative_time, :distance, :waypoint].each do |attribute|
+    it { should respond_to attribute }
+  end
+
+  describe '#waypoint?' do
+    it { should_not be_waypoint }
+
+    context 'when a truthy waypoint value is set' do
+      before { subject.waypoint = true }
+      it { should be_waypoint }
+    end
+
+    context 'when a falsy waypoint value is set' do
+      before { subject.waypoint = false }
+      it { should_not be_waypoint }
+    end
+  end
+
+end

data/spec/routing/parser/navteq_simple_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+require 'json'
+
+describe Routing::Parser::NavteqSimple do
+
+  context 'with a error response' do
+    let(:error_response) { fixture('navteq/error_response.json') }
+
+    it 'should throw an RoutingFailed error' do
+      lambda{ described_class.new(error_response) }.should raise_error(Routing::Parser::RoutingFailed)
+    end
+  end
+
+  context 'with a successful routing response' do
+    let(:response) { fixture('navteq/response.json') }
+    let(:json_response) { JSON.parse(response) }
+    let(:original_geo_points) do
+      json_response['Response']['Route'].first['Waypoint'].collect do |waypoint|
+        mock({
+          lat: waypoint['OriginalPosition']['Latitude'],
+          lng: waypoint['OriginalPosition']['Longitude']
+        })
+      end
+    end
+
+    describe '#to_geo_points' do
+      subject { described_class.new(response).to_geo_points }
+
+      it 'returns geopoints' do
+        subject.each { |point| point.should be_a(::Routing::GeoPoint) }
+      end
+
+      describe 'number of geo points' do
+        let(:leg_size) { json_response["Response"]["Route"].first["Leg"].size }
+        let(:leg_touching_point_size) { leg_size - 1 }
+        let(:maneuver_size) { json_response["Response"]["Route"].first["Leg"].inject(0) { |sum, leg| sum + leg["Maneuver"].size } }
+
+        it 'has the length of all maneuvers minus the duplicate ones at the touching points' do
+          should have(maneuver_size - leg_touching_point_size).geo_points
+        end
+      end
+
+      describe 'coordinates' do
+        it 'sets the calculated latitude and longitude for each geo point' do
+          subject.each do |geo_point|
+            geo_point.lat.should be
+            geo_point.lng.should be
+          end
+        end
+      end
+
+      describe 'original waypoints' do
+        subject { described_class.new(response).to_geo_points.select(&:waypoint?) }
+
+        it 'includes the same number of waypoints as passed in' do
+          should have(original_geo_points.size).geo_points
+        end
+
+        it 'sets original_lat and original_lng on the waypoints' do
+          subject.each_with_index do |geo_point, index|
+            geo_point.original_lat.should eq(original_geo_points[index].lat)
+            geo_point.original_lng.should eq(original_geo_points[index].lng)
+          end
+        end
+
+        context 'when response does not contain the original waypoints' do
+          let(:response) do
+            corrupted_response = JSON.parse(fixture('navteq/response.json'))
+            corrupted_response['Response']['Route'].first['Waypoint'].first['MappedPosition']['Latitude'] += 0.1
+            corrupted_response['Response']['Route'].first['Waypoint'].first['MappedPosition']['Longitude'] += 0.1
+            JSON.dump(corrupted_response)
+          end
+
+          it 'raises an exception if no matching original position was found' do
+            expect { subject }.to raise_error(Routing::Parser::NoMatchingMappedPositionFound)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/routing_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe Routing do
+
+  context 'creating a new instance' do
+
+    let(:adapter) { mock }
+
+    it 'can be called without arguments' do
+      expect { Routing.new }.to_not raise_error
+    end
+
+    it 'uses the default adapter, if no adapter is passed' do
+      described_class.default_adapter.should_receive(:calculate)
+      subject.calculate(stub, stub)
+    end
+
+    it 'takes the passed adapter, if given' do
+      adapter.should_receive(:calculate)
+      described_class.new(adapter).calculate(stub, stub)
+    end
+
+    it 'takes a configuration block' do
+      expect { described_class.new { throw :called } }.to throw_symbol(:called)
+    end
+
+    it 'passes itself to the configuration block' do
+      described_class.new { |r| r.should be_instance_of(described_class) }
+    end
+
+  end
+
+  describe '#calculate' do
+    let(:geo_points) { [stub(:lat => 1, :lng => 2), stub(:lat => 3, :lng => 4), stub(:lat => 5, :lng => 6)] }
+    let(:adapter) { mock(:calculate => geo_points) }
+
+    subject { described_class.new(adapter) }
+
+    it 'should call the adapter' do
+      adapter.should_receive(:calculate).with(geo_points)
+      subject.calculate(geo_points)
+    end
+
+    it 'should call each middleware in the given order' do
+      first_middleware = double(Routing::Middleware)
+      first_middleware.should_receive(:calculate).
+        with(geo_points).and_yield(geo_points)
+
+      second_middleware = double(Routing::Middleware)
+      second_middleware.should_receive(:calculate).
+        with(geo_points)
+
+      subject.stub(:middlewares).and_return([first_middleware, second_middleware])
+
+      subject.calculate(geo_points)
+    end
+  end
+
+  context 'using the middleware' do
+
+    it 'has an empty array of middlewares by default' do
+       subject.middlewares.should be_an(Array)
+       subject.should have(0).middlewares
+    end
+
+    describe '#use' do
+      it 'appends the new middleware to the stack' do
+        subject.use(:hello)
+        subject.use(:world)
+        subject.middlewares.should == [:hello, :world]
+      end
+    end
+
+    describe '#middlewares' do
+      it 'replaces all middlewares' do
+        subject.use(:original)
+        subject.middlewares = :first, :second
+        subject.middlewares.should == [:first, :second]
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+require 'rubygems'
+require 'bundler'
+
+Bundler.require(:default, :test)
+
+module RoutingFixtures
+  def fixture(name)
+    path = File.expand_path("../fixtures/#{name}", __FILE__)
+    File.open(path).read
+  end
+end
+
+RSpec.configure do |config|
+  config.include RoutingFixtures
+end
+
+if File.exist?('.navteq_host')
+  class Routing::Adapter::Navteq
+    def host
+      File.read('.navteq_host')
+    end
+  end
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: routing
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Christian Bäuerlein
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: &70233528536000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70233528536000
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: &70233528535500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70233528535500
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70233528534920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.9.0
+  type: :development
+  prerelease: false
+  version_requirements: *70233528534920
+description: ! "\n    Provides a generic interface for routing services that can by
+  used to calculate directions between geolocations.\n    Makes parsing and use-case
+  specific data handling easy trough an extendable middleware stack.\n  "
+email:
+- christian@ffwdme.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/routing.rb
+- lib/routing/adapter.rb
+- lib/routing/adapter/navteq.rb
+- lib/routing/adapter/test.rb
+- lib/routing/geo_point.rb
+- lib/routing/middleware.rb
+- lib/routing/parser.rb
+- lib/routing/parser/navteq_simple.rb
+- lib/routing/version.rb
+- routing.gemspec
+- spec/fixtures/navteq/error_response.json
+- spec/fixtures/navteq/response.json
+- spec/routing/adapter/navteq_spec.rb
+- spec/routing/adapter/test_spec.rb
+- spec/routing/geo_point_spec.rb
+- spec/routing/parser/navteq_simple_spec.rb
+- spec/routing_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/flinc/routing
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: A ruby interface for route calculation services
+test_files:
+- spec/fixtures/navteq/error_response.json
+- spec/fixtures/navteq/response.json
+- spec/routing/adapter/navteq_spec.rb
+- spec/routing/adapter/test_spec.rb
+- spec/routing/geo_point_spec.rb
+- spec/routing/parser/navteq_simple_spec.rb
+- spec/routing_spec.rb
+- spec/spec_helper.rb
+has_rdoc: