openstreetmap 0.2.1

data/CHANGELOG

@@ -0,0 +1 @@
+v0.1. First version

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2012 Christoph Bünte
+
+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/Manifest

@@ -0,0 +1,29 @@
+CHANGELOG
+LICENSE
+Manifest
+README.md
+Rakefile
+lib/changeset_callbacks.rb
+lib/hash.rb
+lib/open_street_map/api.rb
+lib/open_street_map/basic_auth_client.rb
+lib/open_street_map/changeset.rb
+lib/open_street_map/element.rb
+lib/open_street_map/errors.rb
+lib/open_street_map/member.rb
+lib/open_street_map/node.rb
+lib/open_street_map/oauth_client.rb
+lib/open_street_map/parser.rb
+lib/open_street_map/relation.rb
+lib/open_street_map/tags.rb
+lib/open_street_map/user.rb
+lib/open_street_map/way.rb
+lib/openstreetmap.rb
+openstreetmap.gemspec
+spec/open_street_map/changeset_spec.rb
+spec/open_street_map/node_spec.rb
+spec/open_street_map/relation_spec.rb
+spec/open_street_map/way_spec.rb
+spec/open_street_map_changeset_spec.rb
+spec/open_street_map_node_spec.rb
+spec/open_street_map_way_spec.rb

data/README.md

@@ -0,0 +1,70 @@
+# OpenStreetMap for ruby
+
+[![alt text][2]][1]
+
+  [1]: http://travis-ci.org/#!/sozialhelden/openstreetmap
+  [2]: https://secure.travis-ci.org/sozialhelden/openstreetmap.png
+
+This ruby gem is an API client for the current OpenStreetMap [API v0.6](http://wiki.openstreetmap.org/wiki/API_v0.6). It provides easy access to OpenStreetMap (OSM) data.
+
+## What is OpenStreetMap?
+
+OpenStreetMap (OSM) is a collaborative project to create a free editable map of the world. Two major driving forces behind the establishment and growth of OSM have been restrictions on use or availability of map information across much of the world and the advent of inexpensive portable GPS devices.
+
+
+## The OpenStreetMap Database
+
+OpenStreetMap data is published under an open content license, with the intention of promoting free use and re-distribution of the data (both commercial and non-commercial). The license currently used is the [Creative Commons Attribution-Share Alike 2.0 licence](http://creativecommons.org/licenses/by-sa/2.0/); however, legal investigation work and community consultation is underway to relicense the project under the [Open Database License (ODbL)](http://opendatacommons.org/licenses/odbl/) from [Open Data Commons (ODC)](http://opendatacommons.org/), claimed to be more suitable for a map data set.
+
+## Input Data
+
+All data added to the project need to have a license compatible with the Creative Commons Attribution-Share Alike license. This can include out of copyright information, public domain or other licenses. All contributors must register with the project and agree to provide data on a Creative Commons CC-BY-SA 2.0 licence, or determine that the licensing of the source data is suitable; this may involve examining licences for government data to establish whether they are compatible.
+Due to the license switch, data added in future must be compatible with both the Open Database License and the new Contributor Terms in order to be accepted.
+
+## Installation
+
+Put this in your Gemfile
+
+    # Gemfile
+    gem 'openstreetmap', :git => 'git://github.com/sozialhelden/openstreetmap'
+
+Then run
+
+    bundle install
+
+## Getting started
+
+OK, gimme some code:
+
+    require 'openstreetmap'
+    api = OpenStreetMap::Api.new
+    node = api.find_node(123)
+     => #<OpenStreetMap::Node:0x1019268d0 @changeset=7836598, @timestamp=Mon Apr 11 19:40:43 UTC 2011, @user="Turleder'n", @tags={}, @uid=289426, @version=4, @lat=59.9502252, @id=123, @lon=10.7899133>
+
+Modification of data is supported too. According to the OSM license every modification to the data has to be done by a registered OSM user account. The user can be authenticated with username and password. But see yourself:
+
+    client = OpenStreetMap::BasicAuthClient.new('osm_user_name', 'password')
+    api = OpenStreetMap::Api.new(client)
+    node = OpenStreetMap::Node.new(:lat => 52.0, :lon => 13.4)
+    api.save(node)
+
+Yeah, i can hear you sayin: 'Seriously, do i have to provide username and password? Is that secure?' Providing username and password is prone to some security issues, especially because the OSM API does not provide an SSL service. But wait, there is some more in store for you: [OAuth](http://oauth.net/) It's much more secure for the user and your OSM app. But it comes with a price: You have to register an application on http://www.openstreetmap.org. After you have your app registered you get an app key and secret. Keep it in a save place.
+
+    consumer = OAuth::Consumer.new( 'osm_app_key', 'osm_app_secret',
+                                    { :site => 'http://www.openstreetmap.org',
+                                      :request_token_path => '/oauth/request_token',
+                                      :access_token_path => '/oauth/access_token',
+                                      :authorize_path => '/oauth/authorize'
+                                    })
+    access_token = OAuth::AccessToken.new(consumer, 'osm_user_token', 'osm_user_key')
+    client = OpenStreetMap::OauthClient.new(access_token)
+    api = OpenStreetMap::Api.new(client)
+    node = OpenStreetMap::Node.new(:lat => 52.0, :lon => 13.4)
+    api.save(node)
+
+Every request to the API is now handled by the OauthClient.
+
+
+## Feedback and Contributions
+
+We appreciate your feedback and contributions. If you find a bug, feel free to to open a GitHub issue. Better yet, add a test that exposes the bug, fix it and send us a pull request.

data/Rakefile

@@ -0,0 +1,39 @@
+#coding:utf-8
+require 'rake'
+require 'echoe'
+
+Echoe.new('openstreetmap', '0.2.1') do |p|
+
+ p.description = "OpenStreetMap API client for ruby"
+ p.url         = "https://github.com/sozialhelden/openstreetmap"
+ p.author      = ["Christoph B\303\274nte", "Enno Brehm"]
+ p.email       = ["info@christophbuente.de", "guildenstern@gmx.de"]
+
+ p.retain_gemspec = true
+
+ p.ignore_pattern = %w{
+   Gemfile
+   Gemfile.lock
+   vendor/**/*
+   tmp/*
+   log/*
+   *.tmproj
+ }
+
+ p.runtime_dependencies     = [ "httparty", "libxml-ruby", "builder", "oauth", "activemodel" ]
+ p.development_dependencies = [ "echoe", "rspec", "webmock" ]
+end
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+require 'webmock/rspec'
+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

data/lib/changeset_callbacks.rb

@@ -0,0 +1,31 @@
+# According to the OSM API any changes made to the date need an open changeset which belongs to the user
+# executing the changes.
+# To keep the code simple the before_save method is included which makes sure and open
+module ChangesetCallbacks
+
+  def self.included(into)
+    into.instance_methods(false).select{|method_name| [:save, :create, :update, :destroy].include?(method_name.to_sym)}.each do |m|
+      ChangesetCallbacks.before_write(into, m)
+    end
+
+    def into.method_added(m)
+      unless @adding
+        @adding = true
+        if [:save, :create, :update, :destroy].include?(m.to_sym)
+          ChangesetCallbacks.before_write(self, m)
+        end
+        @adding = false
+      end
+    end
+  end
+
+  def ChangesetCallbacks.before_write(klass, meth)
+    klass.class_eval do
+      alias_method "old_#{meth}", "#{meth}"
+      define_method(meth) do |*args|
+        find_or_create_open_changeset
+        self.send("old_#{meth}", *args)
+      end
+    end
+  end
+end

data/lib/hash.rb

@@ -0,0 +1,19 @@
+class Hash
+
+  define_method(:symbolize_keys!) do
+    self.each do |k,v|
+      self[k.to_sym] = v
+      self.delete(k)
+    end
+  end unless method_defined? :symbolize_keys!
+
+  define_method(:stringify_keys!) do
+    temp_hash = {}
+    self.each do |k,v|
+      temp_hash[k.to_s] = self.delete(k)
+    end
+    temp_hash.each do |k,v|
+      self[k] = v
+    end
+  end unless method_defined? :stringify_keys!
+end

data/lib/open_street_map/api.rb

@@ -0,0 +1,214 @@
+require 'httparty'
+module OpenStreetMap
+  class Api
+    include HTTParty
+    include ChangesetCallbacks
+    API_VERSION = "0.6".freeze
+
+    # the default base URI for the API
+    base_uri "http://www.openstreetmap.org"
+    #base_uri "http://api06.dev.openstreetmap.org/api/#{API_VERSION}"
+
+    default_timeout 5
+
+    parser Parser
+
+    attr_accessor :client
+
+    attr_accessor :changeset
+
+    def initialize(client=nil)
+      @client = client
+    end
+
+    def changeset!
+      @changeset ||= create_changeset
+    end
+
+    # Get a Node with specified ID from API.
+    #
+    # call-seq: find_node(id) -> OpenStreetMap::Node
+    #
+    def find_node(id)
+      find_element('node', id)
+    end
+
+    # Get a Way with specified ID from API.
+    #
+    # call-seq: find_way(id) -> OpenStreetMap::Way
+    #
+    def find_way(id)
+      find_element('way', id)
+    end
+
+    # Get a Relation with specified ID from API.
+    #
+    # call-seq: find_relation(id) -> OpenStreetMap::Relation
+    #
+    def find_relation(id)
+      find_element('relation', id)
+    end
+
+    # Get a Changeset with specified ID from API.
+    #
+    # call-seq: find_changeset(id) -> OpenStreetMap::Changeset
+    #
+    def find_changeset(id)
+      find_element('changeset', id)
+    end
+
+    # Get the user which represented by the OpenStreetMap::Client
+    #
+    # call-seq: find_user -> OpenStreetMap::User
+    #
+    def find_user
+      raise CredentialsMissing if client.nil?
+      resp = do_authenticated_request(:get, "/user/details")
+      raise resp if resp.is_a? String
+      resp
+    end
+
+    # Delete an element
+    def destroy(element)
+      raise ChangesetMissing unless changeset.open?
+      element.changeset = changeset.id
+      response = delete("/#{element.type.downcase}/#{element.id}", :body => element.to_xml) unless element.id.nil?
+      response.to_i # New version number
+    end
+
+    # Saves an element to the API.
+    # If it has no id yet, the element will be created, otherwise updated.
+    def save(element)
+      response = if element.id.nil?
+        create(element)
+      else
+        update(element)
+      end
+    end
+
+    def create(element)
+      put("/#{element.type.downcase}/create", :body => element.to_xml)
+    end
+
+    def update(element)
+      raise ChangesetMissing unless changeset.open?
+      element.changeset = changeset.id
+      response = put("/#{element.type.downcase}/#{element.id}", :body => element.to_xml)
+      response.to_i # New Version number
+    end
+
+    def create_changeset
+      changeset = Changeset.new
+      changeset_id = put("/changeset/create", :body => changeset.to_xml).to_i
+      find_changeset(changeset_id) unless changeset_id == 0
+    end
+
+    def close_changeset
+      put("/changeset/#{changeset.id}/close")
+    end
+
+    def find_changesets_for_user(options = {})
+      user_id = find_user.id
+      changesets = get("/changesets", :query => options.merge({:user => user_id}))
+      changesets.nil? ? [] : changesets
+    end
+
+    private
+
+    # Get an object ('node', 'way', or 'relation') with specified ID from API.
+    #
+    # call-seq: find_element('node', id) -> OpenStreetMap::Element
+    #
+    def find_element(type, id)
+      raise ArgumentError.new("type needs to be one of 'node', 'way', and 'relation'") unless type =~ /^(node|way|relation|changeset)$/
+      raise TypeError.new('id needs to be a positive integer') unless(id.kind_of?(Fixnum) && id > 0)
+      response = get("/#{type}/#{id}")
+      response.is_a?(Array ) ? response.first : response
+    end
+
+    # most GET requests are valid without authentication, so this is the standard
+    def get(url, options = {})
+      do_request(:get, url, options)
+    end
+
+    # all PUT requests need authorization, so this is the stanard
+    def put(url, options = {})
+      do_authenticated_request(:put, url, options)
+    end
+
+    # all POST requests need authorization, so this is the stanard
+    def post(url, options = {})
+      do_authenticated_request(:post, url, options)
+    end
+
+    # all DELETE requests need authorization, so this is the stanard
+    def delete(url, options = {})
+      do_authenticated_request(:delete, url, options)
+    end
+
+    def api_url(url)
+      "/api/#{API_VERSION}" + url
+    end
+
+    # Do a API request without authentication
+    def do_request(method, url, options = {})
+      begin
+        response = self.class.send(method, api_url(url), options)
+        check_response_codes(response)
+        response.parsed_response
+      rescue Timeout::Error
+        raise Unavailable.new('Service Unavailable')
+      end
+    end
+
+    # Do a API request with authentication, using the given client
+    def do_authenticated_request(method, url, options = {})
+      begin
+        response = case client
+                   when BasicAuthClient
+                     self.class.send(method, api_url(url), options.merge(:basic_auth => client.credentials))
+                   when OauthClient
+                     # We have to wrap the result of the access_token request into an HTTParty::Response object
+                     # to keep duck typing with HTTParty
+                     result = client.send(method, api_url(url), options)
+                     content_type = Parser.format_from_mimetype(result.content_type)
+                     parsed_response = Parser.call(result.body, content_type)
+
+                     HTTParty::Response.new(nil, result, parsed_response)
+                   else
+                     raise CredentialsMissing
+                   end
+        check_response_codes(response)
+        response.parsed_response
+      rescue Timeout::Error
+        raise Unavailable.new('Service Unavailable')
+      end
+    end
+
+    def find_open_changeset
+      find_changesets_for_user(:open => true).first
+    end
+
+    def find_or_create_open_changeset(options = {})
+      @changeset = (find_open_changeset || create_changeset)
+    end
+
+    def check_response_codes(response)
+      body = response.body
+      case response.code.to_i
+        when 200 then return
+        when 400 then raise BadRequest.new(body)
+        when 401 then raise Unauthorized.new(body)
+        when 404 then raise NotFound.new(body)
+        when 405 then raise MethodNotAllowed.new(body)
+        when 409 then raise Conflict.new(body)
+        when 410 then raise Gone.new(body)
+        when 412 then raise Precondition.new(body)
+        when 500 then raise ServerError
+        when 503 then raise Unavailable.new('Service Unavailable')
+        else raise Error
+      end
+    end
+
+  end
+end

data/lib/open_street_map/basic_auth_client.rb

@@ -0,0 +1,15 @@
+module OpenStreetMap
+  class BasicAuthClient
+
+    attr_reader :username, :password
+
+    def initialize(username, password)
+      @username = username
+      @password = password
+    end
+
+    def credentials
+      {:username => username, :password => password}
+    end
+  end
+end

data/lib/open_street_map/changeset.rb

@@ -0,0 +1,93 @@
+require 'builder'
+module OpenStreetMap
+  class Changeset
+    # Unique ID
+    attr_reader :id
+
+    # The user who last edited this object (as read from file, it
+    # is not updated by operations to this object)
+    attr_accessor :user
+
+    # The user id of the user who last edited this object (as read from file, it
+    # is not updated by operations to this object)
+    # API 0.6 and above only
+    attr_accessor :uid
+
+    # True if this changeset is still open.
+    attr_accessor :open
+
+    # Creation date of this changeset
+    attr_accessor :created_at
+
+    # When the changeset was closed
+    attr_accessor :closed_at
+
+    # Bounding box surrounding all changes made in this changeset
+    attr_accessor :min_lat, :min_lon, :max_lat, :max_lon
+
+    # Tags for this object
+    attr_reader :tags
+
+    def initialize(attrs = {}) #:nodoc:
+      attrs.stringify_keys!
+      @id         = attrs['id'].to_i if attrs['id']
+      @uid        = attrs['uid'].to_i
+      @user       = attrs['user']
+      @created_at = Time.parse(attrs['created_at']) rescue nil
+      @closed_at  = Time.parse(attrs['closed_at']) rescue nil
+      @open       = attrs['open']
+      @tags       = Tags.new
+      @tags[:created_by] = 'osm for ruby'
+      @min_lat    = attrs['min_lat'].to_f
+      @min_lon    = attrs['min_lon'].to_f
+      @max_lat    = attrs['max_lat'].to_f
+      @max_lon    = attrs['max_lon'].to_f
+
+    end
+
+    # Set timestamp for this object.
+    def created_at=(timestamp)
+      @created_at = Time.parse(timestamp)
+    end
+
+    # Is this changeset still open?
+    def open?
+      ["yes", "1", "t", "true"].include?(open)
+    end
+
+    # List of attributes for a Changeset
+    def attribute_list
+      [:id, :user, :uid, :open, :created_at, :closed_at, :min_lat, :max_lat, :min_lon, :max_lon]
+    end
+
+    # Returns a hash of all non-nil attributes of this object.
+    #
+    # Keys of this hash are <tt>:id</tt>, <tt>:user</tt>,
+    # and <tt>:timestamp</tt>. For a Node also <tt>:lon</tt>
+    # and <tt>:lat</tt>.
+    #
+    # call-seq: attributes -> Hash
+    #
+    def attributes
+      attrs = Hash.new
+      attribute_list.each do |attribute|
+        value = self.send(attribute)
+        attrs[attribute] = value unless value.nil?
+      end
+      attrs
+    end
+
+    def to_xml(options = {})
+      xml = options[:builder] ||= Builder::XmlMarkup.new
+      xml.instruct! unless options[:skip_instruct]
+      xml.osm do
+        xml.changeset(attributes) do
+          tags.each do |k,v|
+            xml.tag(:k => k, :v => v)
+          end unless tags.empty?
+        end
+      end
+    end
+
+  end
+end