cloudmade-wu 0.1.2

data/LICENSE

@@ -0,0 +1,165 @@
+GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

data/README

@@ -0,0 +1,27 @@
+CloudMade
+=========
+
+CloudMadeAPI is a Ruby API for CloudMade's online services: Geocoding, Routing and Tiles.
+
+Full documentation is available online at http://cloudmade.com/developers/docs/
+
+Install
+=======
+
+Using easy_install
+
+	gem install cloudmade
+
+Testing
+=======
+
+To test the source distribution you will need to run following command:
+
+    rake test
+
+Module Documentation
+====================
+
+To generate module documentation you will need to run the following command:
+
+    rake rdoc

data/Rakefile

@@ -0,0 +1,41 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+spec = Gem::Specification.new do |s|
+  s.name = 'cloudmade-wu'
+  s.version = '0.1.2'
+  s.has_rdoc = true
+  s.extra_rdoc_files = ['README', 'LICENSE']
+  s.summary = 'Custom CloudMade Ruby API with Route class renamed to avoid conflicts'
+  s.description = s.summary
+  s.author = 'MarcAliasGus'
+  s.email = 'marc_alias_gus@hotmail.com'
+  s.homepage = 'https://github.com/MarcAliasGus'
+  # s.executables = ['your_executable_here']
+  s.files = %w(LICENSE README Rakefile) + Dir.glob("{bin,lib,spec}/**/*")
+  s.require_path = "lib"
+  s.bindir = "bin"
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  files =['README', 'LICENSE', 'lib/**/*.rb']
+  rdoc.rdoc_files.add(files)
+  rdoc.main = "README" # page to start on
+  rdoc.title = "CloudMadeAPI Docs"
+  rdoc.rdoc_dir = 'doc/rdoc' # rdoc output folder
+  rdoc.options << '--line-numbers'
+end
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/test*.rb']
+end

data/lib/client.rb

@@ -0,0 +1,86 @@
+#
+# Copyright 2009 CloudMade.
+#
+# Licensed under the GNU Lesser General Public License, Version 3.0;
+# You may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.gnu.org/licenses/lgpl-3.0.txt
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+module CloudMade
+  class Client
+    attr_accessor :connection
+    attr_accessor :base_url
+    attr_writer :port
+    attr_accessor :api_key
+    #attr_reader :token
+
+    #:nodoc:
+    def url
+      return "#{base_url}#{@port != nil ? ':' + port.to_s : ''}"
+    end
+
+    #:nodoc:
+    def port
+      return 80 if @port == nil
+      @port
+    end
+
+    # Tiles service
+    def tiles
+      @tiles = TilesService.new(self.connection, 'tile') if @tiles == nil
+      return @tiles
+    end
+
+    # Geocoding service
+    def geocoding
+      @geocoding = GeocodingService.new(self.connection, 'geocoding') if @geocoding == nil
+      return @geocoding
+    end
+
+    # Routing service
+    def routing
+      @routing = RoutingService.new(self.connection, 'routes') if @routing == nil
+      return @routing
+    end
+
+    # Locations service
+    def locations
+      @locations = LocationsService.new(self.connection, '') if @locations == nil
+      return @locations
+    end
+
+    class << self
+      def from_connection(connection)
+        client = Client.new
+        client.connection = connection
+        return client
+      end
+
+      def from_parameters(api_key, base_url = nil, port = nil)
+        client = Client.new
+        client.connection = Connection.new(api_key, base_url, port)
+        return client
+      end
+
+      # TODO: Create here methods to connect from XML and YAML configuration file
+    end
+    
+    protected
+      def initialize()
+      end
+    ### 2. Allow loads configuration from XML, YAML files
+    #def initialize(api_key, base_url = 'cloudmade.com', port = nil)
+    #  @base_url = base_url
+    #  @port = port
+    #  @api_key = api_key
+    #  #@token = token
+    #end
+  end
+end

data/lib/cloudmade.rb

@@ -0,0 +1,25 @@
+#
+# Copyright 2009 CloudMade.
+#
+# Licensed under the GNU Lesser General Public License, Version 3.0;
+# You may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.gnu.org/licenses/lgpl-3.0.txt
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+require 'rubygems'
+require 'connection'
+require 'client'
+require 'geometry'
+require 'service'
+require 'tiles'
+require 'geocoding'
+require 'routing'
+require 'locations'
+require 'exceptions'

data/lib/connection.rb

@@ -0,0 +1,70 @@
+#
+# Copyright 2009 CloudMade.
+#
+# Licensed under the GNU Lesser General Public License, Version 3.0;
+# You may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.gnu.org/licenses/lgpl-3.0.txt
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+module CloudMade
+  # This +Connection+ class provides a connection to CloudMade online services (HTTP API).
+  # Normally you don't need to create it directly. Construct a 'Client' from parameters instead.
+  #
+  # Connection examples:
+  #
+  # conn = CloudMade::Connection.new('cloudmade.com', 80, 'FAKE_API_KEY')
+  # CloudMade.Client.new(conn)
+  #
+  class Connection
+    attr_accessor :base_url
+    attr_writer :port
+    attr_accessor :api_key
+
+    # Initializes connection
+    # * +base_url+ should not start with 'www'
+    # * +port+ integer value of port for CloudMade portal, if nil then default 80 port is used
+    # * +api_key+ your API key to connect to CloudMade services
+    def initialize(api_key = nil, base_url = 'cloudmade.com', port = nil)
+      self.api_key = api_key
+      self.base_url = base_url
+      self.base_url = 'cloudmade.com' if self.base_url == nil or self.base_url.empty?
+      self.port = port
+    end
+
+    # Make a HTTP connection and send a request. Called by the cloudmade 'Client' object internally
+    def connect(server_url, request)
+      #sputs "#{server_url} #{request}"
+      result = nil
+      Net::HTTP.start(server_url, self.port) {|http|
+        req = Net::HTTP::Get.new("#{request}")
+        response = http.request(req)
+        case response
+        when Net::HTTPSuccess, Net::HTTPRedirection
+          result = response.body
+        else
+          raise HTTPError.new("Couldn't read data. HTTP status: #{response}")
+        end
+      }
+      return result
+    end
+
+    # Convenience method. Return the base URL and port of this Connection
+    def url
+      return "#{@base_url}#{@port != nil ? ':' + port.to_s : ''}"
+    end
+
+    # Port number of this Connection
+    def port
+      return 80 if @port == nil
+      @port
+    end
+  end
+end

data/lib/examples.rb

@@ -0,0 +1,23 @@
+require 'cloudmade'
+include CloudMade
+
+cm = CloudMade::Client.from_parameters('BC9A493B41014CAABB98F0471D759707')
+
+puts 'Testing CloudMade Client'
+puts "Geocoding"
+puts "---------"
+puts "Find"
+puts cm.geocoding.find('Potsdamer Platz, Berlin, Germany')
+puts "Find closest"
+puts cm.geocoding.find_closest('pub', 51.66117, 13.37654)
+
+puts "Routing\n-------\n"
+puts cm.routing.route(
+  CloudMade::Point.new(47.25976, 9.58423),
+  CloudMade::Point.new(47.66117, 9.99882))
+
+puts "Tiles\n-----\n"
+tile = cm.tiles.get_tile(50.39947, 30.6479, 15)
+file = File.new('my_tile.png', 'w')
+file.write(tile)
+file.close

data/lib/exceptions.rb

@@ -0,0 +1,35 @@
+#
+# Copyright 2009 CloudMade.
+#
+# Licensed under the GNU Lesser General Public License, Version 3.0;
+# You may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.gnu.org/licenses/lgpl-3.0.txt
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+#Raised when API key is not specified in Connection constructor
+class APIKeyMissingError < Exception
+end
+
+#Raised when object was not found by geocoding service
+class ObjectNotFound < Exception
+end
+
+#Raised when HTTP code other than 200 returned
+class HTTPError < Exception
+end
+
+#Raised when specified route couldn't be found
+class RouteNotFound < Exception
+end
+
+#Raised when geometry is malformed
+class GeometryParseError < Exception
+end

data/lib/geocoding.rb

@@ -0,0 +1,143 @@
+#
+# Copyright 2009 CloudMade.
+#
+# Licensed under the GNU Lesser General Public License, Version 3.0;
+# You may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.gnu.org/licenses/lgpl-3.0.txt
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+module CloudMade
+  require 'cgi'
+
+  # Class that is responsible for geocoding services of Cloudmade
+  class GeocodingService < Service
+
+    # Find objects that match given query. Returns GeoResults object.
+    #
+    # * +query+ Query by which objects should be searched
+    # * +options+ Additional options, contains
+    # results: How many results should be returned.
+    # skip: Number of results to skip from beginning.
+    # bbox: Bounding box in which objects should be searched.
+    # bbox_only: If set to False, results will be searched in the whole world if there are no results for a given bbox.
+    # return_geometry: If specified, adds geometry in returned results. Defaults to true.
+    #
+    def find(query, options = {})
+      options['results'] = 10 unless options.has_key? 'results'
+      options['skip'] = 0 unless options.has_key? 'skip'
+      options['bbox_only'] = true unless options.has_key? 'bbox_only'
+      options['return_geometry'] = true unless options.has_key? 'return_geometry'
+      request = "/find/#{CGI.escape(query)}.js?#{Service.to_url_params(options)}"
+      GeoResults.new(JSON.parse(connect request))
+    end
+
+    # Find closest object to a given point.
+    # For a list of available object types, see:
+    # http://www.cloudmade.com/developers/docs/geocoding-http-api/object_types
+    # Returns GeoResult object, that contain found objects.
+    # Raise ObjectNotFound: Raised when no object could be found in radius of 50 km from point.
+    #
+    # * +object_type+ Type of object, that should be searched.
+    # * +point+ Closest object to this point will be searched.
+    # * +options+ are
+    # * +return_geometry+ If specified, adds geometry in returned results. Defaults to true
+
+    # TODO: Modify lat, lon parameters to point
+    def find_closest(object_type, lat, lon, options = {})
+      lat_lon = "#{CGI.escape(lon.to_s + '+' + lat.to_s)}"
+      request = "/closest/#{object_type}/#{lat_lon}.js?#{Service.to_url_params(options)}"
+      geo_results = GeoResults.new(JSON.parse(connect request))
+      raise ObjectNotFound.new if (geo_results.results == nil or geo_results.results.size == 0)
+      return geo_results.results[0]
+    end
+
+    # :nodoc:
+    def url_template
+      return "http://#{@subdomain}.#{@connection.url}/#{@connection.api_key}/geocoding"
+    end
+  end
+
+  # Location of the object in geographical terms
+  class Location
+    # road: Road on which object is situated
+    attr_accessor :road
+    # city: City, where the object is situated
+    attr_accessor :city
+    # county: County, where the object is situated
+    attr_accessor :county
+    # country: Country in which the object is situated
+    attr_accessor :country
+    # postcode: Postcode, which corresponds to location of the object
+    attr_accessor :postcode
+
+    def initialize(data)
+      self.road = data['road']
+      self.city = data['city']
+      self.county = data['county']
+      self.country = data['country']
+      self.postcode = data['postcode']
+    end
+  end
+
+  # Parsed results of geocoding request
+  class GeoResults
+    # Founded results
+    attr_accessor :found
+    # List of found GeoResult objects
+    attr_accessor :results
+    # Bounds of result set
+    attr_accessor :bounds
+
+    def initialize(data)
+      self.found = Integer(data['found'])
+      if (data['features'] != nil) then
+        self.results = data['features'].map { |feature_data| CloudMade::GeoResult.new(feature_data) }
+      end
+      self.bounds = CloudMade::BBox.from_coordinates(data['bounds']) if data.has_key? 'bounds'
+    end
+
+    def to_s
+      results.join(',') if results != nil
+    end
+  end
+
+  class GeoResult
+    # Id of the object
+    attr_accessor :id
+    # Geometry of the object
+    attr_accessor :geometry
+    # Centroid of the object
+    attr_accessor :centroid
+    # Bounds of result set
+    attr_accessor :bounds
+    # Properties of the object
+    attr_accessor :properties
+    # Location of the object
+    attr_accessor :location
+
+    def initialize(data)
+      self.id = data['id']
+      self.geometry = CloudMade::Geometry.parse(data['geometry'])
+      self.centroid = CloudMade::Geometry.parse(data['centroid'])
+      self.bounds = CloudMade::BBox.from_coordinates(data['bounds']) if data.has_key? 'bounds'
+      self.properties = data['properties']
+      if data.has_key? 'location'
+        self.location = Location.new(data['location'])
+      else
+        self.location = nil
+      end
+    end
+
+    def to_s
+      self.geometry.to_s
+    end
+  end
+end

data/lib/geometry.rb

@@ -0,0 +1,139 @@
+#
+# Copyright 2009 CloudMade.
+#
+# Licensed under the GNU Lesser General Public License, Version 3.0;
+# You may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.gnu.org/licenses/lgpl-3.0.txt
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+module CloudMade
+  class Geometry
+
+    class << self
+      def parse(data)
+        return nil if data == nil
+        case data['type'].downcase
+        when 'point' then return Point.new(data['coordinates'])
+        when 'line' then return Line.new(data['coordinates'])
+        when 'multilinestring' then return MultiLine.new(data['coordinates'])
+        when 'polygon' then return Polygon.new(data['coordinates'])
+        when 'multipolygon' then return MultiPolygon.new(data['coordinates'])
+        end
+      end
+    end
+  end
+
+  class Point < Geometry
+    attr_accessor :lat
+    attr_accessor :lon
+
+    # Posible initializers are
+    # Point.new(1, -1)
+    # Point.new([1, -1])
+    def initialize(*args)
+      if args.size == 1
+        @lat = args[0][0]
+        @lon = args[0][1]
+      elsif args.size == 2
+        @lat = args[0]
+        @lon = args[1]
+      end
+    end
+
+    def ==(point)
+      return (point.lat == @lat and point.lon == @lon)
+    end
+
+    def to_s
+      "Point(#{@lat},#{@lon})"
+    end
+
+    def to_latlon
+      "#{@lat},#{@lon}"
+    end
+  end
+
+  class Line < Geometry
+    attr_accessor :points
+
+    def initialize(coords)
+      @points = coords.map { |latlng| Point.new(latlng) }
+    end
+
+    def to_s
+      "Line(#{@points.join(',')})"
+    end
+  end
+
+
+  class MultiLine < Geometry
+    attr_accessor :lines
+
+    def initialize(coords)
+      @lines = coords.map { |line_coords| Line.new(line_coords) }
+    end
+
+    def to_s
+      "MultiLine(#{@lines.join(',')})"
+    end
+  end
+
+  class Polygon < Geometry
+    attr_accessor :border_line
+    attr_accessor :holes
+
+    def initialize(coords)
+      @border_line = Line.new(coords[0])
+      @holes = coords.slice(1, coords.length).map { |line_coords| Line.new(line_coords) }
+    end
+
+    def to_s
+      "Polygon(#{@border_line} - (#{@holes.join(',')}))"
+    end
+  end
+
+  class MultiPolygon < Geometry
+    attr_accessor :polygons
+
+    def initialize(coords)
+      @polygons = coords.map { |poly_coords| Polygon.new(poly_coords) }
+    end
+
+    def to_s
+      "MultiPolygon(#{@polygons.join(',')})"
+    end
+  end
+
+  class BBox < Geometry
+    attr_accessor :points
+    
+    def initialize(points)
+      self.points = points
+    end
+
+    class << self
+      def from_points(points)
+        return BBox.new(points)
+      end
+
+      def from_coordinates(coords)
+        point1 = Point.new(coords[0][0], coords[0][1])
+        point2 = Point.new(coords[1][0], coords[1][1])
+        return BBox.new([point1, point2])
+      end
+    end
+
+    def ==(bbox)
+      return (bbox.points[0] == self.points[0] and bbox.points[1] = self.points[1] or
+          bbox.points[0] == self.points[1] and bbox.points[1] = self.points[0])
+    end
+  end
+end

data/lib/locations.rb

@@ -0,0 +1,20 @@
+#
+# Copyright 2009 CloudMade.
+#
+# Licensed under the GNU Lesser General Public License, Version 3.0;
+# You may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.gnu.org/licenses/lgpl-3.0.txt
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+module CloudMade
+  class LocationsService < Service
+  end
+end

data/lib/routing.rb

@@ -0,0 +1,145 @@
+#
+# Copyright 2009 CloudMade.
+#
+# Licensed under the GNU Lesser General Public License, Version 3.0;
+# You may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.gnu.org/licenses/lgpl-3.0.txt
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'cgi'
+require 'json'
+
+module CloudMade
+
+  #Class corresponding for CloudMade's routing service
+  class RoutingService < Service
+
+    ROUTE_TYPES = ['car', 'foot', 'bicycle']
+    OUTPUT_FORMATS = ['js', 'json', 'gpx']
+    STATUS_OK = 0
+    STATUS_ERROR = 1
+    EARTHS_DIRECTIONS = ["N", "NE", "E", "SE", "S", "SW", "W", "NW"]
+    TURN_TYPE = ["C", "TL", "TSLL", "TSHL", "TR", "TSLR", "TSHR", "U"]
+
+    # Build route. Returns route that was found, instance of CloudMade::Route2
+    # * +start_point+ Starting point
+    # * +end_point+ Ending point
+    # * +route_type+ Type of route, e.g. 'car', 'foot', etc.
+    # * +transit_points+ List of points route must visit before
+    #   reaching end. Points are visited in the same order they are
+    #   specified in the sequence.
+    # * +route_type_modifier+ Modifier of the route type
+    # * +lang+ Language code in conformance to `ISO 3166-1 alpha-2` standard
+    # * +units+ Measure units for distance calculation
+    def route(start_point, end_point, transit_points = nil, route_type = 'car', lang = 'en', route_type_modifier = nil)
+      transit_points = ",[#{transit_points.map {|point| point.to_latlon}.join(',')}]" if not transit_points == nil
+      route_type_modifier = "/#{route_type_modifier}" if not route_type_modifier == nil
+      url = "/#{start_point.to_latlon}#{transit_points},#{end_point.to_latlon}/#{route_type}#{route_type_modifier}.js?lang=#{lang}&units=km"
+      return CMRoute.new(JSON.parse(connect url))
+    end
+
+    #:nodoc:
+    def url_template
+      return "http://#{@subdomain}.#{@connection.url}/#{@connection.api_key}/api/0.3"
+    end
+  end
+
+
+  # Statistics of the route
+  class RouteSummary
+    attr_accessor :total_distance
+    attr_accessor :total_time
+    attr_accessor :start_point
+    attr_accessor :end_point
+    attr_accessor :transit_points
+
+    def initialize(summary)
+        self.total_distance = Float(summary['total_distance'])
+        self.total_time = Float(summary['total_time'])
+        self.start_point = summary['start_point']
+        self.end_point = summary['end_point']
+        self.transit_points = summary['transit_points']
+    end
+  end
+
+  # Wrapper around raw data being returned by routing service
+  class CMRoute
+
+    # List of route instructions
+    attr_accessor :instructions
+    # Statistical info about the route
+    attr_accessor :summary
+    # Geometry of route
+    attr_accessor :geometry
+    #Version of routing HTTP API
+    attr_accessor :version    
+    # Status of response
+    attr_accessor :status
+    attr_accessor :status_message
+
+    STATUS_OK = 0
+    STATUS_ERROR = 1
+
+    def initialize(data)
+      begin
+        self.status = data['status'].to_i
+        self.instructions = data['route_instructions'].map { |instruction_data| RouteInstruction.new(instruction_data) }
+        self.summary = RouteSummary.new(data['route_summary'])
+        self.geometry = Line.new(data['route_geometry'])
+        self.version = data['version']
+        self.status_message = data['status_message']
+      rescue
+        raise RouteNotFound
+      end
+    end
+
+    def to_s
+      self.instructions.to_s
+    end
+  end
+
+  # Instructions on route passing
+  class RouteInstruction
+
+    # Text instruction
+    attr_reader :instruction
+    # Length of the segment in meters
+    attr_reader :length
+    # Index of the first point of the segment
+    attr_reader :position
+    # Estimated time required to travel the segment in seconds
+    attr_reader :time
+    # Length of the segments in specified units
+    attr_reader :length_caption
+    # Earth direction
+    attr_reader :earth_direction
+    # North-based azimuth
+    attr_reader :azimuth
+    # Code of the turn type
+    attr_reader :turn_type
+    # Angle in degress of the turn between two segments
+    attr_reader :turn_angle
+
+    def initialize(data)
+      @instruction = data[0]
+      @length = Float(data[1])
+      @position = Integer(data[2])
+      @time = Integer(data[3])
+      @length_caption = data[4]
+      @earth_direction = data[5]
+      @azimuth = Float(data[6])
+      if data.length == 9
+        @turn_type = data[7]
+        @turn_angle = data[8]
+      end
+    end
+  end
+end

data/lib/service.rb

@@ -0,0 +1,53 @@
+#
+# Copyright 2009 CloudMade.
+#
+# Licensed under the GNU Lesser General Public License, Version 3.0;
+# You may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.gnu.org/licenses/lgpl-3.0.txt
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+module CloudMade
+
+  # General class for all CloudMade's services
+  class Service
+    require 'net/http'
+    require 'cgi'
+    attr_accessor :subdomain
+    attr_accessor :connection
+
+    def url_template
+      return "http://#{@subdomain}.#{@connection.url}/#{@connection.api_key}"
+    end
+
+    # Template for service's domain
+    # By default it is <service_name>.cloudmade.com
+    # E.g. tile.cloudmade.com, geocoding.cloudmade.com
+    def url
+      "#{@subdomain}.#{@connection.base_url}"
+    end
+
+    class << self
+      def to_url_params(params)
+        params.map {|k,v| "#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}" }.join('&')
+      end
+    end
+
+    protected
+      def initialize(connection, subdomain)
+        self.connection = connection
+        self.subdomain = subdomain
+      end
+
+      def connect(request)
+        return @connection.connect(url, "#{url_template}#{request}")
+      end
+  end
+end

data/lib/tiles.rb

@@ -0,0 +1,105 @@
+#
+# Copyright 2009 CloudMade.
+#
+# Licensed under the GNU Lesser General Public License, Version 3.0;
+# You may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.gnu.org/licenses/lgpl-3.0.txt
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+include CloudMade
+
+module CloudMade
+
+  # Class that is responsible for tile services of Cloudmade
+  class TilesService < Service
+    attr_accessor :default_tile_size
+    attr_accessor :default_style_id
+
+    def initialize(client, subdomain, options = {})
+      super(client, subdomain)
+      @default_tile_size = (options.has_key? 'tile_size') ? options['tile_size'] : 256
+      @default_style_id = (options.has_key? 'style_id') ? options['style_id'] : 1
+    end
+
+    # Convert latitude, longitude pair to tile coordinates. Returns tile coordinates as a CloudMade::Point object
+    # * +lat+ Latitude
+    # * +lon+ Longitude
+    # * +zoom+ Zoom level
+    def latlon2tilenums(lat, lon, zoom)
+      factor = 2**(zoom - 1)
+      lat = radians(lat)
+      lon = radians(lon)
+      xtile = 1 + lon / Math::PI
+      ytile = 1 - Math.log(Math.tan(lat) + (1 / Math.cos(lat))) / Math::PI
+      return Point.new((xtile * factor).to_i, (ytile * factor).to_i)
+    end
+
+    # Convert tile coordinates pair to latitude, longitude. Returns latitude, longitude as a CloudMade::Point object
+    # * +xtile+ X coordinate of the tile
+    # * +ytile+ Y coordinate of the tile
+    # * +zoom+ Zoom level
+    def tilenums2latlon(xtile, ytile, zoom)
+      factor = 2.0 ** zoom
+      lon = (xtile * 360 / factor) - 180.0
+      lat = Math.atan(Math.sinh(Math::PI * (1 - 2 * ytile / factor)))
+      return Point.new(degrees(lat), lon)
+    end
+
+    # :nodoc:
+    def radians(degrees)
+      Math::PI * degrees / 180
+    end
+
+    def degrees(radians)
+      radians * 180 / Math::PI
+    end
+
+    def xtile(lon, zoom)
+      factor = 2**(zoom - 1)
+      xtile = 1 + lon / 180.0
+      return (xtile * factor).to_i
+    end
+
+    def ytile(lat, zoom)
+      factor = 2**(zoom - 1)
+      lat = radians(lat)
+      ytile = 1 - Math.log(Math.tan(lat) + (1 / Math.cos(lat))) / Math::PI
+      return (ytile * factor).to_i
+    end
+
+    # Get tile with given latitude, longitude and zoom.
+    # Returns Raw PNG data which could be saved to file
+    #
+    # * +lat+ Latitude of requested tile
+    # * +lon+ Longitude of requested tile
+    # * +zoom+ Zoom level, on which tile is being requested
+    # * +style_id+ CloudMade's style id, if not given, default style is used (usually 1)
+    # * +tile_size+ size of tile, if not given the default 256 is used
+    def get_tile(lat, lon, zoom, style_id = nil, tile_size = nil)
+      get_xy_tile(xtile(lon, zoom), ytile(lat, zoom), zoom, style_id, tile_size)
+    end
+
+    # Get tile with given x, y numbers and zoom
+    # Returns Raw PNG data which could be saved to file
+    #
+    # * +xtile+
+    # * +ytile+
+    # * +zoom+ Zoom level, on which tile is being requested
+    # * +style_id+ CloudMade's style id, if not given, default style is used (usually 1)
+    # * +tile_size+ size of tile, if not given the default 256 is used
+    def get_xy_tile(xtile, ytile, zoom, style_id = nil, tile_size = nil)
+      style_id = self.default_style_id if style_id == nil
+      tile_size = self.default_tile_size if tile_size == nil
+      connect "/#{style_id}/#{tile_size}/#{zoom}/#{xtile}/#{ytile}.png"
+    end
+  end
+
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: cloudmade-wu
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+  prerelease: 
+platform: ruby
+authors:
+- MarcAliasGus
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-23 00:00:00.000000000 Z
+dependencies: []
+description: Custom CloudMade Ruby API with Route class renamed to avoid conflicts
+email: marc_alias_gus@hotmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README
+- LICENSE
+files:
+- LICENSE
+- README
+- Rakefile
+- lib/client.rb
+- lib/cloudmade.rb
+- lib/connection.rb
+- lib/examples.rb
+- lib/exceptions.rb
+- lib/geocoding.rb
+- lib/geometry.rb
+- lib/locations.rb
+- lib/routing.rb
+- lib/service.rb
+- lib/tiles.rb
+homepage: https://github.com/MarcAliasGus
+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.24
+signing_key: 
+specification_version: 3
+summary: Custom CloudMade Ruby API with Route class renamed to avoid conflicts
+test_files: []