routing 0.0.4 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6f2365563b9f8bbdedbfc071a7617b1d0d5865d1
-  data.tar.gz: f39f04367027d8d773ff8e9e98246fc29649f701
+  metadata.gz: 7a49e29dbffb57a00e02111ebb486d6ef57c48d9
+  data.tar.gz: 0a4104acf4545f919bee3a4c7b22cdc8eb14076b
 SHA512:
-  metadata.gz: 3bc6220170518feca7a9ba21ae7a0c4af6ba7a3cbe51b8ee5996f53f2a9552747acee5d74a02bf79ca19cc471ae45ea30073ca8a40b0b0784495dffc43757ef1
-  data.tar.gz: fe3dde7390ad12fbed60fa4647877f16a82adef21ad1dad3dcd68e60ed4fecbf14f9e850c2c4d5c757e4be8897eaf1afe1c25206cdeafc8ee567942479d2b22b
+  metadata.gz: 10aa9dc049fe739036ce6149ec156735179a51bb8a33cb72ea2902d5a55d530402e40e35011801bfd631e104690b1022a3c1a9ca28fbda23199e82f5b32b331d
+  data.tar.gz: 98ebd1ea41a04d78d9aa8712fd2503bead5fd27640387a5fd54640e5d68d016d188906d4b74e7e278f153f9de0cfe5e6c7ef1ad03800a0e2f60e90584e456424

data/lib/routing.rb

@@ -16,16 +16,16 @@ class Routing
     attr_writer :default_adapter
 
     # The default adapter/routing service that is used, if no one is specified.
-    # Currently this is {Routing::Adapter::Navteq}.
+    # Currently this is {Routing::Adapter::Here}.
     #
     # @return [Object] Current default adapter.
     def default_adapter
-      @default_adapter ||= Routing::Adapter::Navteq.new
+      @default_adapter ||= Routing::Adapter::Here.new
     end
 
   end
 
-  attr_accessor :middlewares
+  attr_reader :adapter
 
   # Creates a new instance of the routing class
   #
@@ -37,6 +37,14 @@ class Routing
     yield(self) if block_given?
   end
 
+  # Returns a copy of the current middleware stack.
+  #
+  # @return [Array<Routing::Middleware>]
+  #   An array of all registered middlewares.
+  def middlewares
+    @middlewares.dup
+  end
+
   # Calculates a route for the passed {GeoPoint}s.
   # These will be passed through the middleware stack and will
   # finally be given to the configured adapter which calculates a route out of it.

data/lib/routing/adapter.rb

@@ -17,6 +17,7 @@ class Routing
 
     autoload :Here, "routing/adapter/here"
     autoload :Navteq, "routing/adapter/navteq"
+    autoload :RestAdapter, "routing/adapter/rest_adapter"
     autoload :Test, "routing/adapter/test"
 
   end

data/lib/routing/adapter/here.rb

@@ -1,39 +1,15 @@
 require 'time'
-require 'faraday'
 
 class Routing
   module Adapter
-
     # Adapter for a Nokia Here Routing Service v7 server.
     # It passes the {GeoPoint}s to the routing service and will return another
     # Array of {GeoPoint}s, representing the calculated route.
-    class Here
-
-      def initialize(options = {})
-        @options = {
-          :host => 'http://route.api.here.com',
-          :service_path => '/routing/7.2/calculateroute.json',
-          :parser => ::Routing::Parser::HereSimple
-        }.merge(options)
-      end
-
-      def calculate(geo_points)
-        response = connection.get do |request|
-          request.url(options[:service_path])
-          request.params = default_params.merge(geo_points_to_params(geo_points)).merge(options[:credentials])
-        end
-
-        parse(response.body)
-      end
+    class Here < RestAdapter
+      property :credentials, accepts: Hash
 
-      private
-
-      def parse(response)
-        options[:parser].new(response).to_geo_points
-      end
-
-      def default_params
-        options[:default_params] || {
+      def self.default_params
+        {
           departure:          Time.now.utc.iso8601,
           mode:               "fastest;car",
           language:           "de_DE",
@@ -42,21 +18,17 @@ class Routing
         }
       end
 
-      def geo_points_to_params(geo_points)
-        Hash[geo_points.each_with_index.map { |point, i| [ "waypoint#{i}", "geo!#{point.lat},#{point.lng}" ] }]
-      end
-
-      def connection
-        @connection ||= Faraday.new(:url => options[:host]) do |builder|
-          builder.request  :url_encoded
-          builder.adapter  :net_http
-        end
+      def initialize(attrs = {})
+        attrs[:host] ||= 'route.api.here.com'
+        attrs[:path] ||= '/routing/7.2/calculateroute.json'
+        attrs[:parser] ||= ::Routing::Parser::HereSimple
+        super(attrs)
       end
 
-      def options
-        @options || {}
+      def calculate(geo_points)
+        response = request(params.merge(convert_geo_points_to_params(geo_points)).merge(credentials))
+        parse(response.body)
       end
-
     end
   end
 end

data/lib/routing/adapter/navteq.rb

@@ -1,37 +1,13 @@
 require 'time'
-require 'faraday'
 
 class Routing
   module Adapter
-
     # Adapter for a NAVTEQ LBSP Routing Service v6 server.
     # It passes the {GeoPoint}s to the routing service and will return another
     # Array of {GeoPoint}s, representing the calculated route.
-    class Navteq
-
-      def initialize(options = {})
-        @options = {
-          :service_path => '/routing/6.2/calculateroute.json',
-          :parser => ::Routing::Parser::NavteqSimple
-        }.merge(options)
-      end
-
-      def calculate(geo_points)
-        response = connection.get do |request|
-          request.url(options[:service_path])
-          request.params = default_params.merge(geo_points_to_params(geo_points))
-        end
-        parse(response.body)
-      end
-
-      private
-
-      def parse(response)
-        options[:parser].new(response).to_geo_points
-      end
-
-      def default_params
-        options[:default_params] || {
+    class Navteq < RestAdapter
+      def self.default_params
+        {
           departure:          Time.now.utc.iso8601,
           mode0:              "fastest;car",
           language:           "de_DE",
@@ -40,21 +16,11 @@ class Routing
         }
       end
 
-      def geo_points_to_params(geo_points)
-        Hash[geo_points.each_with_index.map { |point, i| [ "waypoint#{i}", "geo!#{point.lat},#{point.lng}" ] }]
-      end
-
-      def connection
-        @connection ||= Faraday.new(:url => options[:host]) do |builder|
-          builder.request  :url_encoded
-          builder.adapter  :net_http
-        end
+      def initialize(attrs = {})
+        attrs[:path] ||= '/routing/6.2/calculateroute.json'
+        attrs[:parser] ||= ::Routing::Parser::NavteqSimple
+        super(attrs)
       end
-
-      def options
-        @options || {}
-      end
-
     end
   end
-end
+end

data/lib/routing/adapter/rest_adapter.rb

@@ -0,0 +1,60 @@
+require 'time'
+require 'faraday'
+require 'smart_properties'
+
+class Routing
+  module Adapter
+    class RestAdapter
+      include SmartProperties
+
+      property :scheme, converts: :to_str, accepts: ['http', 'https'], default: 'http', required: true
+      property :host, converts: :to_str, required: true
+      property :path, converts: :to_str, required: true
+      property :parser, accepts: Class
+      property :params, accepts: Hash
+
+      def self.default_params
+        {}
+      end
+
+      def calculate(geo_points)
+        response = request(params.merge(convert_geo_points_to_params(geo_points)))
+        parse(response.body)
+      end
+
+      def params
+        super || self.class.default_params
+      end
+
+      private
+
+      def base_url
+        "%s://%s" % [scheme, host]
+      end
+
+      def request(params = nil)
+        connection.get do |request|
+          request.url(path)
+          request.params = params if params
+          yield request if block_given?
+        end
+      end
+
+      def connection
+        @connection ||= Faraday.new(url: base_url) do |builder|
+          builder.request  :url_encoded
+          builder.adapter  :net_http
+        end
+      end
+
+      def parse(response)
+        parser.new(response).to_geo_points
+      end
+
+      def convert_geo_points_to_params(geo_points)
+        Hash[geo_points.each_with_index.map { |point, i| [ "waypoint#{i}", "geo!#{point.lat},#{point.lng}" ] }]
+      end
+    end
+  end
+end
+

data/lib/routing/parser/here_simple.rb

@@ -46,7 +46,7 @@ class Routing
         # For the last leg we parse the last maneuver right at the end
         maneuvers = leg["maneuver"][0...-1]
         maneuvers.map do |maneuver|
-          parse_maneuver(maneuver, :waypoint => (maneuver == maneuvers.first))
+          parse_maneuver(maneuver, waypoint: (maneuver == maneuvers.first))
         end
       end
 
@@ -89,7 +89,7 @@ class Routing
       # @raise [NoMatchingMappedPositionFound] If no matching original position is found.
       def search_original_position(geo_point)
         matching_waypoint = @route["waypoint"].detect do |waypoint|
-          waypoint["mappedPosition"]["latitude"]  == geo_point.lat && 
+          waypoint["mappedPosition"]["latitude"]  == geo_point.lat &&
           waypoint["mappedPosition"]["longitude"] == geo_point.lng
         end or raise NoMatchingMappedPositionFound
 

data/lib/routing/parser/navteq_simple.rb

@@ -46,7 +46,7 @@ class Routing
         # For the last leg we parse the last maneuver right at the end
         maneuvers = leg["Maneuver"][0...-1]
         maneuvers.map do |maneuver|
-          parse_maneuver(maneuver, :waypoint => (maneuver == maneuvers.first))
+          parse_maneuver(maneuver, waypoint: (maneuver == maneuvers.first))
         end
       end
 
@@ -89,7 +89,7 @@ class Routing
       # @raise [NoMatchingMappedPositionFound] If no matching original position is found.
       def search_original_position(geo_point)
         matching_waypoint = @route["Waypoint"].detect do |waypoint|
-          waypoint["MappedPosition"]["Latitude"]  == geo_point.lat && 
+          waypoint["MappedPosition"]["Latitude"]  == geo_point.lat &&
           waypoint["MappedPosition"]["Longitude"] == geo_point.lng
         end or raise NoMatchingMappedPositionFound
 
@@ -107,4 +107,4 @@ class Routing
 
     end
   end
-end
+end

data/lib/routing/version.rb

@@ -1,3 +1,3 @@
 class Routing
-  VERSION = "0.0.4"
+  VERSION = "0.1.0"
 end

data/routing.gemspec

@@ -13,7 +13,9 @@ Gem::Specification.new do |gem|
 
   gem.add_dependency "faraday", ">= 0.7.0"
   gem.add_dependency "json"
-  gem.add_development_dependency "rspec", ">= 2.9.0"
+  gem.add_dependency "smart_properties", "~> 1.0"
+  gem.add_development_dependency "rspec", ">= 2.11"
+  gem.add_development_dependency "rake"
 
   gem.files         = `git ls-files`.split($\)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
@@ -21,4 +23,4 @@ Gem::Specification.new do |gem|
   gem.name          = "routing"
   gem.require_paths = ["lib"]
   gem.version       = Routing::VERSION
-end
+end

data/spec/routing/adapter/here_spec.rb

@@ -2,23 +2,27 @@ require 'spec_helper'
 
 describe Routing::Adapter::Here do
 
-  let(:response) { mock(:response).as_null_object }
-  let(:request) { mock(:request).as_null_object }
-  let(:connection) { mock(:connection).as_null_object }
-  let(:parser_class) { mock(:parser_class, :new => parser) }
-  let(:parser) { mock(:parser).as_null_object }
-
+  let(:response) { double(:response).as_null_object }
+  let(:request) { double(:request).as_null_object }
+  let(:connection) { double(:connection).as_null_object }
+  let(:parser_class) do
+    Class.new.tap do |klass|
+      klass.stub(:new => parser)
+    end
+  end
+  let(:parser) { double(:parser).as_null_object }
+  let(:credentials) { {:app_id => "123", :app_code => "456"} }
   let(:options) do
-    { :parser => parser_class, :credentials => { :app_id => "123", :app_code => "456" } }
+    { :parser => parser_class, :credentials => credentials}
   end
 
-  let(:geo_points) { [stub(:lat => 1, :lng => 2), stub(:lat => 3, :lng => 4), stub(:lat => 5, :lng => 6)] }
+  let(:geo_points) { [double(:lat => 1, :lng => 2), double(:lat => 3, :lng => 4), double(:lat => 5, :lng => 6)] }
 
-  subject { described_class.new(options) }
+  subject(:adapter) { described_class.new(options) }
 
   before do
-    connection.stub(:get).and_yield(request).and_return(response)
-    Faraday.stub(:new).and_return(connection)
+    allow(connection).to receive(:get).and_yield(request).and_return(response)
+    allow(Faraday).to receive(:new).and_return(connection)
   end
 
   context 'creating a new instance' do
@@ -27,37 +31,51 @@ describe Routing::Adapter::Here do
     end
 
     it 'allows setting the host' do
-      Faraday.should_receive(:new).with(:url => 'http://other.com')
-      options.merge!(:host => 'http://other.com')
+      expect(Faraday).to receive(:new).with(:url => 'http://other.com')
+
+      adapter = described_class.new(options.merge!(:host => 'other.com'))
+      adapter.calculate(geo_points)
     end
 
     it 'allows setting the default params' do
       params = { :hello => "world" }
-      options.merge!(:default_params => params)
-      request.should_receive(:params=).with(hash_including(params))
+      expect(request).to receive(:params=).with(hash_including(params))
+
+      adapter = described_class.new(options.merge(:params => params))
+      adapter.calculate(geo_points)
     end
 
     it 'sets the api credentials' do
-      request.should_receive(:params=).with(hash_including({ :app_id => "123", :app_code => "456" }))
+      expect(request).to receive(:params=).with(hash_including({ :app_id => "123", :app_code => "456" }))
+      adapter.calculate(geo_points)
     end
 
     it 'should allow setting the service path' do
-      options.merge!(:service_path => '/some/path.json')
-      request.should_receive(:url).with('/some/path.json')
+      expect(request).to receive(:url).with('/some/path.json')
+
+      adapter = described_class.new(options.merge(:path => '/some/path.json'))
+      adapter.calculate(geo_points)
     end
 
     it 'should use a default service path when none is given' do
-      request.should_receive(:url).with('/routing/7.2/calculateroute.json')
+      expect(request).to receive(:url).with('/routing/7.2/calculateroute.json')
+
+      adapter = described_class.new(options)
+      adapter.calculate(geo_points)
     end
 
     it 'should allow setting the parser' do
-      options.merge!(:parser => parser_class)
-      parser_class.should_receive(:new)
+      expect(parser_class).to receive(:new)
+
+      adapter = described_class.new(options.merge(:parser => parser_class))
+      adapter.calculate(geo_points)
     end
 
     it 'should use a default parser when none is given' do
-      options.delete(:parser)
-      Routing::Parser::HereSimple.should_receive(:new).and_return(parser)
+      expect(Routing::Parser::HereSimple).to receive(:new).and_return(parser)
+
+      adapter = described_class.new(credentials: credentials)
+      adapter.calculate(geo_points)
     end
 
     it 'ignores unknown options' do
@@ -68,21 +86,23 @@ describe Routing::Adapter::Here do
   describe '#calculate' do
     it 'passes the response to the parser' do
       response.stub(:body => '...')
-      parser_class.should_receive(:new).with('...')
+      expect(parser_class).to receive(:new).with('...')
+      adapter.calculate(geo_points)
     end
 
     it 'should return the parser\'s result' do
       result = [double, double, double]
       parser.stub(:to_geo_points => result)
-      subject.calculate(geo_points).should be(result)
+      expect(adapter.calculate(geo_points)).to be(result)
     end
 
     it 'should convert the geo points into a compatible format' do
-      request.should_receive(:params=).with hash_including({
+      expect(request).to receive(:params=).with hash_including({
         'waypoint0' => 'geo!1,2',
         'waypoint1' => 'geo!3,4',
         'waypoint2' => 'geo!5,6'
       })
+      adapter.calculate(geo_points)
     end
   end
 end

data/spec/routing/adapter/navteq_spec.rb

@@ -1,85 +1,93 @@
 require 'spec_helper'
 
 describe Routing::Adapter::Navteq do
+  let(:response) { double(:response).as_null_object }
+  let(:request) { double(:request).as_null_object }
+  let(:connection) { double(:connection).as_null_object }
+  let(:parser_class) do
+    Class.new.tap do |klass|
+      klass.stub(new: parser)
+    end
+  end
+  let(:parser) { double(:parser).as_null_object }
+  let(:options) { { host: 'example.com', parser: parser_class } }
+  let(:geo_points) { [double(lat: 1, lng: 2), double(lat: 3, lng: 4), double(lat: 5, lng: 6)] }
 
-  let(:response) { mock(:response).as_null_object }
-  let(:request) { mock(:request).as_null_object }
-  let(:connection) { mock(:connection).as_null_object }
-  let(:parser_class) { mock(:parser_class, :new => parser) }
-  let(:parser) { mock(:parser).as_null_object }
-
-  let(:options) { { :host => 'http://example.com', :parser => parser_class } }
-
-  let(:geo_points) { [stub(:lat => 1, :lng => 2), stub(:lat => 3, :lng => 4), stub(:lat => 5, :lng => 6)] }
-
-
-  subject { described_class.new(options) }
+  subject(:adapter) { described_class.new(options) }
 
   before do
-    connection.stub(:get).and_yield(request).and_return(response)
-    Faraday.stub(:new).and_return(connection)
+    allow(connection).to receive(:get).and_yield(request).and_return(response)
+    allow(Faraday).to receive(:new).and_return(connection)
   end
 
   after { subject.calculate(geo_points) }
 
   context 'creating a new instance' do
-    it 'can be instantiated without arguments' do
-      expect { described_class.new }.to_not raise_error
-    end
-
     it 'allows setting the host' do
-      Faraday.should_receive(:new).with(:url => 'http://other.com')
-      options.merge!(:host => 'http://other.com')
+      expect(Faraday).to receive(:new).with(url: 'http://other.com')
+
+      adapter = described_class.new(options.merge(host: 'other.com'))
+      adapter.calculate(geo_points)
     end
 
     it 'allows setting the default params' do
-      params = { :hello => "world" }
-      options.merge!(:default_params => params)
-      request.should_receive(:params=).with(hash_including(params))
+      params = {hello: "world"}
+      expect(request).to receive(:params=).with(hash_including(params))
+
+      adapter = described_class.new(options.merge(params: params))
+      adapter.calculate(geo_points)
     end
 
     it 'should allow setting the service path' do
-      options.merge!(:service_path => '/some/path.json')
-      request.should_receive(:url).with('/some/path.json')
+      expect(request).to receive(:url).with('/some/path.json')
+
+      adapter = described_class.new(options.merge(path: '/some/path.json'))
+      adapter.calculate(geo_points)
     end
 
     it 'should use a default service path when none is given' do
-      request.should_receive(:url).with('/routing/6.2/calculateroute.json')
+      expect(request).to receive(:url).with('/routing/6.2/calculateroute.json')
+      adapter.calculate(geo_points)
     end
 
     it 'should allow setting the parser' do
-      options.merge!(:parser => parser_class)
-      parser_class.should_receive(:new)
+      expect(parser_class).to receive(:new)
+
+      adapter = described_class.new(options.merge(parser: parser_class))
+      adapter.calculate(geo_points)
     end
 
     it 'should use a default parser when none is given' do
-      options.delete(:parser)
-      Routing::Parser::NavteqSimple.should_receive(:new).and_return(parser)
+      expect(Routing::Parser::NavteqSimple).to receive(:new).and_return(parser)
+
+      adapter = described_class.new(host: 'example.com')
+      adapter.calculate(geo_points)
     end
 
     it 'ignores unknown options' do
-      expect { described_class.new(:hello => "world") }.to_not raise_error
+      expect { described_class.new(options.merge(hello: "world")) }.to_not raise_error
     end
   end
 
   describe '#calculate' do
     it 'passes the response body to the parser' do
-      response.stub(:body => '...')
-      parser_class.should_receive(:new).with('...')
+      response.stub(body: '...')
+      expect(parser_class).to receive(:new).with('...')
+      adapter.calculate(geo_points)
     end
 
     it 'should return the parser\'s result' do
       result = [double, double, double]
-      parser.stub(:to_geo_points => result)
-      subject.calculate(geo_points).should be(result)
+      parser.stub(to_geo_points: result)
+      expect(subject.calculate(geo_points)).to be(result)
     end
 
     it 'should convert the geo points into a compatible format' do
-      request.should_receive(:params=).with hash_including({
+      expect(request).to receive(:params=).with hash_including({
         'waypoint0' => 'geo!1,2',
         'waypoint1' => 'geo!3,4',
         'waypoint2' => 'geo!5,6'
       })
     end
   end
-end
+end

data/spec/routing/adapter/test_spec.rb

@@ -1,29 +1,23 @@
 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)] }
+    let(:geo_points) { [double(lat: 1, lng: 2), double(lat: 3, lng: 4), double(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
+        expect(new_geo_point.lat).to eql(geo_points[index].lat)
+        expect(new_geo_point.lng).to eql(geo_points[index].lng)
+        expect(new_geo_point.original_lng).to eql(geo_points[index].lng)
+        expect(new_geo_point.original_lng).to eql(geo_points[index].lng)
+        expect(new_geo_point).to be_waypoint
       end
     end
-
   end
-
-end
+end

data/spec/routing/geo_point_spec.rb

@@ -10,8 +10,15 @@ describe Routing::GeoPoint do
     context 'initialized with attributes' do
       subject { described_class.new(:lat => 1, :lng => 2) }
 
-      its(:lat) { should be(1) }
-      its(:lng) { should be(2) }
+      describe '#lat' do
+        subject { super().lat }
+        it { should be(1) }
+      end
+
+      describe '#lng' do
+        subject { super().lng }
+        it { should be(2) }
+      end
 
       it 'ignores passed attributes that dont exist' do
         expect { described_class.new(:hello => :world) }.to_not raise_error

data/spec/routing/parser/here_simple_spec.rb

@@ -2,12 +2,11 @@ require 'spec_helper'
 require 'json'
 
 describe Routing::Parser::HereSimple do
-
   context 'with a error response' do
     let(:error_response) { fixture('here/error_response.json') }
 
     it 'should throw an RoutingFailed error' do
-      lambda{ described_class.new(error_response) }.should raise_error(Routing::Parser::RoutingFailed)
+      expect{ described_class.new(error_response) }.to raise_error(Routing::Parser::RoutingFailed)
     end
   end
 
@@ -16,7 +15,7 @@ describe Routing::Parser::HereSimple do
     let(:json_response) { JSON.parse(response) }
     let(:original_geo_points) do
       json_response['response']['route'].first['waypoint'].collect do |waypoint|
-        mock({
+        double({
           lat: waypoint['originalPosition']['latitude'],
           lng: waypoint['originalPosition']['longitude']
         })
@@ -27,7 +26,7 @@ describe Routing::Parser::HereSimple do
       subject { described_class.new(response).to_geo_points }
 
       it 'returns geopoints' do
-        subject.each { |point| point.should be_a(::Routing::GeoPoint) }
+        subject.each { |point| expect(point).to be_a(::Routing::GeoPoint) }
       end
 
       describe 'number of geo points' do
@@ -36,15 +35,15 @@ describe Routing::Parser::HereSimple do
         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
+          expect(subject.size).to eq(maneuver_size - leg_touching_point_size)
         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
+            expect(geo_point.lat).to be
+            expect(geo_point.lng).to be
           end
         end
       end
@@ -53,13 +52,13 @@ describe Routing::Parser::HereSimple 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
+          expect(subject.size).to eq(original_geo_points.size)
         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)
+            expect(geo_point.original_lat).to eq(original_geo_points[index].lat)
+            expect(geo_point.original_lng).to eq(original_geo_points[index].lng)
           end
         end
 

data/spec/routing/parser/navteq_simple_spec.rb

@@ -2,12 +2,11 @@ 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)
+      expect{ described_class.new(error_response) }.to raise_error(Routing::Parser::RoutingFailed)
     end
   end
 
@@ -16,7 +15,7 @@ describe Routing::Parser::NavteqSimple do
     let(:json_response) { JSON.parse(response) }
     let(:original_geo_points) do
       json_response['Response']['Route'].first['Waypoint'].collect do |waypoint|
-        mock({
+        double({
           lat: waypoint['OriginalPosition']['Latitude'],
           lng: waypoint['OriginalPosition']['Longitude']
         })
@@ -27,7 +26,7 @@ describe Routing::Parser::NavteqSimple do
       subject { described_class.new(response).to_geo_points }
 
       it 'returns geopoints' do
-        subject.each { |point| point.should be_a(::Routing::GeoPoint) }
+        subject.each { |point| expect(point).to be_a(::Routing::GeoPoint) }
       end
 
       describe 'number of geo points' do
@@ -36,15 +35,15 @@ describe Routing::Parser::NavteqSimple do
         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
+          expect(subject.size).to eq(maneuver_size - leg_touching_point_size)
         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
+            expect(geo_point.lat).to be
+            expect(geo_point.lng).to be
           end
         end
       end
@@ -53,13 +52,13 @@ describe Routing::Parser::NavteqSimple 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
+          expect(subject.size).to eq(original_geo_points.size)
         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)
+            expect(geo_point.original_lat).to eq(original_geo_points[index].lat)
+            expect(geo_point.original_lng).to eq(original_geo_points[index].lng)
           end
         end
 
@@ -78,4 +77,4 @@ describe Routing::Parser::NavteqSimple do
       end
     end
   end
-end
+end

data/spec/routing_spec.rb

@@ -1,23 +1,21 @@
 require 'spec_helper'
 
 describe Routing do
-
   context 'creating a new instance' do
-
-    let(:adapter) { mock }
+    let(:adapter) { double }
 
     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)
+      expect(described_class.default_adapter).to receive(:calculate)
+      subject.calculate(double, double)
     end
 
     it 'takes the passed adapter, if given' do
-      adapter.should_receive(:calculate)
-      described_class.new(adapter).calculate(stub, stub)
+      expect(adapter).to receive(:calculate)
+      described_class.new(adapter).calculate(double, double)
     end
 
     it 'takes a configuration block' do
@@ -25,58 +23,48 @@ describe Routing do
     end
 
     it 'passes itself to the configuration block' do
-      described_class.new { |r| r.should be_instance_of(described_class) }
+      described_class.new { |r| expect(r).to 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) }
+    let(:geo_points) { [double(lat: 1, lng: 2), double(lat: 3, lng: 4), double(lat: 5, lng: 6)] }
+    let(:adapter) { double(calculate: geo_points) }
 
     subject { described_class.new(adapter) }
 
     it 'should call the adapter' do
-      adapter.should_receive(:calculate).with(geo_points)
+      expect(adapter).to 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).
+      expect(first_middleware).to receive(:calculate).
         with(geo_points).and_yield(geo_points)
 
       second_middleware = double(Routing::Middleware)
-      second_middleware.should_receive(:calculate).
+      expect(second_middleware).to receive(:calculate).
         with(geo_points)
 
-      subject.stub(:middlewares).and_return([first_middleware, second_middleware])
+      allow(subject).to receive(: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
+       expect(subject.middlewares).to be_an(Array)
+       expect(subject.middlewares.size).to eq(0)
     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]
+        expect(subject.middlewares).to eq([:hello, :world])
       end
     end
   end
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: routing
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0
 platform: ruby
 authors:
 - Christian Bäuerlein
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-20 00:00:00.000000000 Z
+date: 2014-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -39,20 +39,48 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: smart_properties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.9.0
+        version: '2.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.9.0
+        version: '0'
 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  "
@@ -73,6 +101,7 @@ files:
 - lib/routing/adapter.rb
 - lib/routing/adapter/here.rb
 - lib/routing/adapter/navteq.rb
+- lib/routing/adapter/rest_adapter.rb
 - lib/routing/adapter/test.rb
 - lib/routing/geo_point.rb
 - lib/routing/middleware.rb
@@ -112,7 +141,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: A ruby interface for route calculation services