gmaps_directions 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+gem "activesupport", "~> 3.0.4"
+gem "yajl-ruby", "~> 0.8.1", :require => "yajl"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec", "~> 2.5.0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+  gem "rcov", ">= 0"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Dirk Breuer
+
+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.rdoc

@@ -0,0 +1,70 @@
+= gmaps_directions
+
+Sometimes you need to calculate the directions between two different points via
+Google Maps on your server-side and not on the client. The Google Maps API for
+that is dead simple and due to this I wrapped calling the API in this little gem.
+
+The gem talks to the Google Maps Directions Web Service API. Detailed documentation
+for that can be found here: http://code.google.com/apis/maps/documentation/directions/
+This API allows up to 2.500 direction requests. At the current version there is no
+way to use the non-public interface for Google Premium Maps customers. If you want that
+feature right now drop me a patch or wait until I need it too (which might not take too
+long anyway).
+
+One last thing for the interested: The gem consumes the JSON response format from Google
+API and parses it through the Ruby Yajl JSON parser.
+
+== Example
+
+Here is an example of how to use the Gem. As you can see, it is really more than simple:
+
+    require 'rubygems'
+    require 'gmaps_directions'
+
+    route = GmapsDirections::API.find_directions :from => "1 Infinite Loop, Cupertino",
+                                                 :to => "1200 Park Avenue, Emmerville"
+
+    route.duration.should           == 3462
+    route.formatted_duration.should == "58 mins"
+    route.distance.should           == 84826
+    route.formatted_distance.should == "84.8 km"
+    route.start_address.should      == "1 Infinite Loop, Cupertino, CA 95014, USA"
+    route.end_address.should        == "1200 Park Ave, Emeryville, CA 94608, USA"
+    route.start_location.should     == { "lat" => 37.3316900, "lng" => -122.0312600 }
+    route.end_location.should       == { "lat" => 37.8317100, "lng" => -122.2833000 }
+    route.status.should             == "OK"
+
+== Configuration
+
+Despite the fact that you cannot provide an API-Key I already built some kind of configuration.
+In detail you can configure the following options when talking to Google:
+
+* The type of transportation to use when calculate the direction ('driving', 'walking', 'bicycling')
+* The unit system to use ('metric', 'imperial')
+* The language in which the results is outputted (this includes number formats)
+* The availability of a GPS-sensor
+* Should there alternative routes be calculated
+
+The following snippet shows how to configure those options and what are the defaults:
+
+    GmapsDirections::Config.mode         = :driving
+    GmapsDirections::Config.units        = :metric
+    GmapsDirections::Config.language     = :en
+    GmapsDirections::Config.sensor       = false
+    GmapsDirections::Config.alternatives = false
+
+== Contributing to gmaps_directions
+
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 Dirk Breuer. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "gmaps_directions"
+  gem.homepage = "http://github.com/railsbros_dirk/gmaps_directions"
+  gem.license = "MIT"
+  gem.summary = %Q{A simple Gem to use the Google Maps distance API from Ruby}
+  gem.description = %Q{
+    Sometimes you need to calculate the directions between two different points
+    via Google Maps on your server-side and not on the client. The Google Maps
+    API for that is dead simple and due to this I wrapped calling the API in
+    this little gem.
+  }
+  gem.email = "dirk.breuer@gmail.com"
+  gem.authors = ["Dirk Breuer"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+   gem.add_runtime_dependency 'yajl-ruby', '~> 0.8.1'
+   gem.add_runtime_dependency 'activesupport', '~> 3.0.4'
+   gem.add_development_dependency 'rspec', '~> 2.5'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "gmaps_directions #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/gmaps_directions.rb

@@ -0,0 +1,79 @@
+require 'yajl'
+require 'yajl/http_stream'
+require 'uri'
+require 'active_support/configurable'
+require 'active_support/ordered_options'
+
+module GmapsDirections
+
+  class Config
+    DEFAULTS = [:mode, :driving, :units, :metric, :language, :en, :sensor, false, :alternatives, false]
+
+    class <<self
+      include ActiveSupport::Configurable
+      config_accessor :mode, :units, :language, :sensor, :alternatives
+
+      def config
+        @config ||= ActiveSupport::OrderedOptions[*DEFAULTS]
+      end
+
+      def reset_to_defaults!
+        @config = ActiveSupport::OrderedOptions[*DEFAULTS]
+      end
+
+      def to_url_options
+        config.inject([]) { |url_options, option| url_options << "#{option.first.to_s}=#{URI.escape(option.last.to_s)}" }.join("&")
+      end
+    end
+  end
+
+  class API
+    class <<self
+      def find_directions(options = {})
+        api_driver = new(:start_address => options[:from], :end_address => options[:to])
+        api_driver.call_google
+        return Route.new(api_driver.parsed_directions_response)
+      end
+    end
+
+    DIRECTIONS_API_BASE_URL = "http://maps.googleapis.com/maps/api/directions/json"
+
+    attr_reader :start_address, :end_address, :parsed_directions_response
+
+    def initialize(attributes)
+      @start_address = attributes[:start_address]
+      @end_address   = attributes[:end_address]
+    end
+
+    def call_google
+      Yajl::HttpStream.get(directions_api_url) do |results_hash|
+        @parsed_directions_response = results_hash
+      end
+    end
+
+    private
+      
+      def directions_api_url
+        URI.parse("#{DIRECTIONS_API_BASE_URL}?origin=#{URI.escape(start_address)}&destination=#{URI.escape(end_address)}&#{Config.to_url_options}")
+      end
+  end
+
+  class Route
+    attr_reader :duration, :formatted_duration, :distance, :formatted_distance,
+                :start_address, :end_address, :start_location, :end_location,
+                :status
+    
+    def initialize(directions_api_response_hash)
+      @duration           = directions_api_response_hash["routes"].first["legs"].first["duration"]["value"]
+      @formatted_duration = directions_api_response_hash["routes"].first["legs"].first["duration"]["text"]
+      @distance           = directions_api_response_hash["routes"].first["legs"].first["distance"]["value"]
+      @formatted_distance = directions_api_response_hash["routes"].first["legs"].first["distance"]["text"]
+      @start_address      = directions_api_response_hash["routes"].first["legs"].first["start_address"]
+      @end_address        = directions_api_response_hash["routes"].first["legs"].first["end_address"]
+      @start_location     = directions_api_response_hash["routes"].first["legs"].first["start_location"]
+      @end_location       = directions_api_response_hash["routes"].first["legs"].first["end_location"]
+      @status             = directions_api_response_hash["status"]
+    end
+  end
+
+end

data/spec/gmaps_directions_spec.rb

@@ -0,0 +1,147 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "GmapsDirections" do
+
+  it 'should provide a way to calculate the directions between points speficied by address' do
+    start_address = "Somestr. 23, 99999 Any City"
+    end_address   = "Just Avenue 42, 11111 Sin City"
+
+    directions_api_url = URI.parse("http://maps.googleapis.com/maps/api/directions/json?origin=#{URI.encode(start_address)}&destination=#{URI.encode(end_address)}&mode=driving&units=metric&language=en&sensor=false&alternatives=false")
+    Yajl::HttpStream.should_receive(:get).with(directions_api_url)
+    GmapsDirections::Route.should_receive(:new)
+
+    GmapsDirections::API.find_directions :from => start_address, :to => end_address
+  end
+
+  describe "should have a Config object" do
+
+    before(:each) do
+      GmapsDirections::Config.reset_to_defaults!
+    end
+    
+    it 'should provide a way to configure some defaults when talking with the directions API' do
+      GmapsDirections::Config.mode = :walking
+      GmapsDirections::Config.mode.should == :walking
+
+      GmapsDirections::Config.units = :imperial
+      GmapsDirections::Config.units.should == :imperial
+
+      GmapsDirections::Config.language = :de
+      GmapsDirections::Config.language.should == :de
+
+      GmapsDirections::Config.sensor = true
+      GmapsDirections::Config.sensor.should be(true)
+
+      GmapsDirections::Config.alternatives = true
+      GmapsDirections::Config.alternatives.should be(true)
+    end
+
+    it 'should provide a meaningful default configuration out of the box' do
+      GmapsDirections::Config.mode.should           == :driving
+      GmapsDirections::Config.units.should          == :metric
+      GmapsDirections::Config.language.should       == :en
+      GmapsDirections::Config.sensor.should         be(false)
+      GmapsDirections::Config.alternatives.should   be(false)
+    end
+
+    it 'should transform the config to URL options' do
+      GmapsDirections::Config.to_url_options.should == "mode=driving&units=metric&language=en&sensor=false&alternatives=false"
+    end
+
+  end
+
+  describe "should wrap Google's JSON response in a nice object and" do
+
+    before(:each) do
+      @route = GmapsDirections::Route.new(
+        {
+          "status" => "OK",
+          "routes" => [ {
+            "summary" => "Luxemburger Str./B265",
+            "legs" => [ {
+              "steps" => [ { 
+                "travel_mode" => "DRIVING",
+                "start_location" => { "lat" => 50.9280500, "lng" => 6.9397100 },
+                "end_location" => { "lat" => 50.9274800, "lng" => 6.9397800 },
+                "polyline" => { },
+                "duration" => { "value" => 11, "text" => "1 min" },
+                "html_instructions" => "",
+                "distance" => { "value" => 63, "text" => "63 m" }
+              } ],
+              "duration" => {
+                "value" => 476,
+                "text" => "8 mins"
+              },
+              "distance" => {
+                "value" => 3166,
+                "text" => "3.2 km"
+              },
+              "start_location" => { "lat" => 50.9280500, "lng" => 6.9397100 },
+              "end_location" => { "lat" => 50.9093600, "lng" => 6.9246200 },
+              "start_address" => "Somestr. 23, 99999 Any City, USA",
+              "end_address" => "Just Avenue 42, 11111 Sin City, USA",
+              "via_waypoint" => [ ]
+            } ],
+            "copyrights" => "Map data ©2011 Tele Atlas",
+            "overview_polyline" => { },
+            "warnings" => [ ],
+            "waypoint_order" => [ ],
+            "bounds" => { }
+          } ]
+        }
+      )
+    end
+    
+    it 'should provide a getter to the duration' do
+      @route.duration.should == 476
+    end
+
+    it 'should provide a getter to the localized and formatted duration' do
+      @route.formatted_duration.should == "8 mins"
+    end
+
+    it 'should provide a getter to the distance' do
+      @route.distance.should == 3166
+    end
+
+    it 'should provide a getter to the localized and formatted distance' do
+      @route.formatted_distance.should == "3.2 km"
+    end
+
+    it 'should provide a getter to the submitted start address' do
+      @route.start_address.should == "Somestr. 23, 99999 Any City, USA"
+    end
+
+    it 'should provide a getter to the submitted end address' do
+      @route.end_address.should == "Just Avenue 42, 11111 Sin City, USA"
+    end
+
+    it 'should provide a getter to the geocoordinates of the start address' do
+      @route.start_location.should == { "lat" => 50.9280500, "lng" => 6.9397100 }
+    end
+
+    it 'should provide a getter to the geocoordinates of the end address' do
+      @route.end_location.should == { "lat" => 50.9093600, "lng" => 6.9246200 }
+    end
+
+    it 'should provide a getter to status of the Google response' do
+      @route.status.should == "OK"
+    end
+
+  end
+
+  it 'should perform a real request see if everything is parsed correctly' do
+    route = GmapsDirections::API.find_directions :from => "1 Infinite Loop, Cupertino",
+                                                 :to => "1200 Park Avenue, Emmerville"
+
+    route.duration.should           == 3462
+    route.formatted_duration.should == "58 mins"
+    route.distance.should           == 84826
+    route.formatted_distance.should == "84.8 km"
+    route.start_address.should      == "1 Infinite Loop, Cupertino, CA 95014, USA"
+    route.end_address.should        == "1200 Park Ave, Emeryville, CA 94608, USA"
+    route.start_location.should     == { "lat" => 37.3316900, "lng" => -122.0312600 }
+    route.end_location.should       == { "lat" => 37.8317100, "lng" => -122.2833000 }
+    route.status.should             == "OK"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'gmaps_directions'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+end

metadata

@@ -0,0 +1,218 @@
+--- !ruby/object:Gem::Specification 
+name: gmaps_directions
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Dirk Breuer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-13 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :runtime
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 3
+        - 0
+        - 4
+        version: 3.0.4
+  name: activesupport
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :runtime
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 61
+        segments: 
+        - 0
+        - 8
+        - 1
+        version: 0.8.1
+  name: yajl-ruby
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 2
+        - 5
+        - 0
+        version: 2.5.0
+  name: rspec
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  name: bundler
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 5
+        - 2
+        version: 1.5.2
+  name: jeweler
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: rcov
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :runtime
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 61
+        segments: 
+        - 0
+        - 8
+        - 1
+        version: 0.8.1
+  name: yajl-ruby
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :runtime
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 3
+        - 0
+        - 4
+        version: 3.0.4
+  name: activesupport
+  version_requirements: *id008
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  requirement: &id009 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 2
+        - 5
+        version: "2.5"
+  name: rspec
+  version_requirements: *id009
+description: "\n    Sometimes you need to calculate the directions between two different points\n    via Google Maps on your server-side and not on the client. The Google Maps\n    API for that is dead simple and due to this I wrapped calling the API in\n    this little gem.\n  "
+email: dirk.breuer@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .document
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/gmaps_directions.rb
+- spec/gmaps_directions_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/railsbros_dirk/gmaps_directions
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: A simple Gem to use the Google Maps distance API from Ruby
+test_files: 
+- spec/gmaps_directions_spec.rb
+- spec/spec_helper.rb