openstreetmap 0.2.1

data/lib/open_street_map/parser.rb

@@ -0,0 +1,123 @@
+require 'httparty'
+require 'xml/libxml'
+class OpenStreetMap::Parser < HTTParty::Parser
+  include LibXML::XML::SaxParser::Callbacks
+
+  attr_accessor :context, :description, :lang, :collection
+
+  def parse
+    return nil if body.nil? || body.empty?
+    if supports_format?
+      self.send(format) # This is a hack, cause the xml format would not be recognized ways, but for nodes and relations
+    else
+      body
+    end
+  end
+
+  def xml
+    @parser = LibXML::XML::SaxParser.string(body)
+    @parser.callbacks = self
+    @parser.parse
+    @collection.empty? ? @context : @collection
+  end
+
+  def plain
+    body
+  end
+
+  def on_start_document   # :nodoc:
+    @collection = []
+    start_document if respond_to?(:start_document)
+  end
+
+  def on_end_document     # :nodoc:
+    end_document if respond_to?(:end_document)
+  end
+
+  def on_start_element(name, attr_hash)   # :nodoc:
+    case name
+    when 'node'         then _start_node(attr_hash)
+    when 'way'          then _start_way(attr_hash)
+    when 'relation'     then _start_relation(attr_hash)
+    when 'changeset'    then _start_changeset(attr_hash)
+    when 'user'         then _start_user(attr_hash)
+    when 'tag'          then _tag(attr_hash)
+    when 'nd'           then _nd(attr_hash)
+    when 'member'       then _member(attr_hash)
+    when 'home'         then _home(attr_hash)
+    when 'description'  then @description = true
+    when 'lang'         then @lang        = true
+    end
+  end
+
+  def on_end_element(name)   # :nodoc:
+    case name
+    when 'description'  then @description = false
+    when 'lang'         then @lang        = false
+    when 'changeset'    then _end_changeset
+    end
+  end
+
+  def on_characters(chars)
+    if @context.class.name == 'OpenStreetMap::User'
+      if @description
+        @context.description = chars
+      end
+      if @lang
+        @context.languages << chars
+      end
+    end
+  end
+
+  private
+
+  def _start_node(attr_hash)
+    @context = OpenStreetMap::Node.new(attr_hash)
+  end
+
+  def _start_way(attr_hash)
+    @context = OpenStreetMap::Way.new(attr_hash)
+  end
+
+  def _start_relation(attr_hash)
+    @context = OpenStreetMap::Relation.new(attr_hash)
+  end
+
+  def _start_changeset(attr_hash)
+    @context = OpenStreetMap::Changeset.new(attr_hash)
+  end
+
+  def _end_changeset
+    @collection << @context
+  end
+
+  def _start_user(attr_hash)
+    @context = OpenStreetMap::User.new(attr_hash)
+  end
+
+  def _nd(attr_hash)
+    @context << attr_hash['ref']
+  end
+
+  def _tag(attr_hash)
+    if respond_to?(:tag)
+      return unless tag(@context, attr_hash['k'], attr_value['v'])
+    end
+    @context.tags.merge!(attr_hash['k'] => attr_hash['v'])
+  end
+
+  def _member(attr_hash)
+    new_member = OpenStreetMap::Member.new(attr_hash['type'], attr_hash['ref'], attr_hash['role'])
+    if respond_to?(:member)
+      return unless member(@context, new_member)
+    end
+    @context.members << new_member
+  end
+
+  def _home(attr_hash)
+    @context.lat = attr_hash['lat']   if attr_hash['lat']
+    @context.lon = attr_hash['lon']   if attr_hash['lon']
+    @context.lon = attr_hash['zoom']  if attr_hash['zoom']
+  end
+
+end

data/lib/open_street_map/relation.rb

@@ -0,0 +1,52 @@
+module OpenStreetMap
+  # OpenStreetMap Relation.
+  #
+  # To create a new OpenStreetMap::Relation object:
+  #   relation = OpenStreetMap::Relation.new()
+  #
+  # To get a relation from the API:
+  #   relation = OpenStreetMap::Relation.find(17)
+  #
+  class Relation < Element
+    # Array of Member objects
+    attr_reader :members
+
+    # Create new Relation object.
+    #
+    # If +id+ is +nil+ a new unique negative ID will be allocated.
+    def initialize(attrs)
+      attrs.stringify_keys!
+      @members = extract_member(attrs['member'])
+      super(attrs)
+    end
+
+    def type
+      'relation'
+    end
+
+    # Return XML for this relation. This method uses the Builder library.
+    # The only parameter ist the builder object.
+    def to_xml(option = {})
+      xml = options[:builder] ||= Builder::XmlMarkup.new
+      xml.instruct! unless options[:skip_instruct]
+      xml.relation(attributes) do
+        members.each do |member|
+          member.to_xml(:builder => xml, :skip_instruct => true)
+        end
+        tags.to_xml(:builder => xml, :skip_instruct => true)
+      end
+    end
+
+    protected
+
+    def extract_member(member_array)
+      return [] unless member_array && member_array.size > 0
+
+      member_array.inject([]) do |memo, member|
+        class_to_instantize = "OpenStreetMap::#{member['type'].classify}".constantize
+        memo << class_to_instantize.new(:id => member['ref'])
+      end
+    end
+
+  end
+end

data/lib/open_street_map/tags.rb

@@ -0,0 +1,26 @@
+module OpenStreetMap
+  # A collection of OSM tags which can be attached to a Node, Way,
+  # or Relation.
+  # It is a subclass of Hash.
+  class Tags < Hash
+
+    # Return XML for these tags. This method uses the Builder library.
+    # The only parameter ist the builder object.
+    def to_xml(options = {})
+      xml = options[:builder] ||= Builder::XmlMarkup.new
+      xml.instruct! unless options[:skip_instruct]
+      each do |key, value|
+        xml.tag(:k => key, :v => value)
+      end unless empty?
+    end
+
+    # Return string with comma separated key=value pairs.
+    #
+    # call-seq: to_s -> String
+    #
+    def to_s
+      sort.collect{ |k, v| "#{k}=#{v}" }.join(', ')
+    end
+
+  end
+end

data/lib/open_street_map/user.rb

@@ -0,0 +1,34 @@
+require 'builder'
+module OpenStreetMap
+  class User
+    # Unique ID
+    attr_reader :id
+
+    # Display name
+    attr_reader :display_name
+
+    # When this user was created
+    attr_reader :account_created
+
+    # A little prosa about this user
+    attr_accessor :description
+
+    # All languages the user can speak
+    attr_accessor :languages
+
+    # Lat/Lon Coordinates of the users home.
+    attr_accessor :lat, :lon, :zoom
+
+    # A picture from this user
+    attr_accessor :img
+
+    def initialize(attrs = {})
+      attrs.stringify_keys!
+      @id               = attrs['id'].to_i if attrs['id']
+      @display_name     = attrs['display_name']
+      @account_created  = Time.parse(attrs['account_created']) rescue nil
+      @languages         = []
+    end
+
+  end
+end

data/lib/open_street_map/way.rb

@@ -0,0 +1,84 @@
+module OpenStreetMap
+  # OpenStreetMap Way.
+  #
+  # To create a new OpenStreetMap::Way object:
+  #   way = OpenStreetMap::Way.new()
+  #
+  # To get a way from the API:
+  #   way = OpenStreetMap::Way.find_way(17)
+  #
+  class Way < Element
+    # Array of node IDs in this way.
+    attr_reader :nodes
+
+    # Create new Way object.
+    #
+    # id:: ID of this way. If +nil+ a new unique negative ID will be allocated.
+    # user:: Username
+    # timestamp:: Timestamp of last change
+    # nodes:: Array of Node objects and/or node IDs
+    def initialize(attrs = {})
+      attrs.stringify_keys!
+      @nodes = []
+      super(attrs)
+    end
+
+    def type
+        'Way'
+    end
+
+    # Add one or more tags or nodes to this way.
+    #
+    # The argument can be one of the following:
+    #
+    # * If the argument is a Hash or an OSM::Tags object, those tags are added.
+    # * If the argument is an OSM::Node object, its ID is added to the list of node IDs.
+    # * If the argument is an Integer or String containing an Integer, this ID is added to the list of node IDs.
+    # * If the argument is an Array the function is called recursively, i.e. all items in the Array are added.
+    #
+    # Returns the way to allow chaining.
+    #
+    # call-seq: way << something -> Way
+    #
+    def <<(stuff)
+      case stuff
+        when Array  # call this method recursively
+          stuff.each do |item|
+            self << item
+          end
+        when OpenStreetMap::Node
+          nodes << stuff.id
+        when String
+          nodes << stuff.to_i
+        when Integer
+          nodes << stuff
+        else
+          tags.merge!(stuff)
+       end
+       self    # return self to allow chaining
+    end
+
+
+    # The list of attributes for this Way
+    def attribute_list # :nodoc:
+      [:id, :version, :uid, :user, :timestamp, :changeset]
+    end
+
+    def self.from_xml(xml_string)
+      Parser.call(xml_string, :xml)
+    end
+
+    def to_xml(options = {})
+      xml = options[:builder] ||= Builder::XmlMarkup.new
+      xml.instruct! unless options[:skip_instruct]
+      xml.osm do
+        xml.way(attributes) do
+          nodes.each do |node_id|
+            xml.nd(:ref => node_id)
+          end unless nodes.empty?
+          tags.to_xml(:builder => xml, :skip_instruct => true)
+        end
+      end
+    end
+  end
+end

data/lib/openstreetmap.rb

@@ -0,0 +1,31 @@
+require 'hash'
+require 'active_model'
+require 'changeset_callbacks'
+require 'open_street_map/tags'
+require 'open_street_map/element'
+require 'open_street_map/node'
+require 'open_street_map/way'
+require 'open_street_map/changeset'
+require 'open_street_map/relation'
+require 'open_street_map/member'
+require 'open_street_map/user'
+require 'open_street_map/errors'
+require 'open_street_map/basic_auth_client'
+require 'open_street_map/oauth_client'
+require 'open_street_map/parser'
+require 'open_street_map/api'
+require 'oauth'
+
+# The OpenStreetMap class handles all calls to the OpenStreetMap API.
+#
+# Usage:
+#   require 'osm'
+#   auth_client = OpenStreetMap::BasicAuthClient.new(:user_name => 'user', :password => 'a_password')
+#   osm = OpenStreetMap.new(auth_client)
+#   @node = osm.find_node(1234)
+#   @node.tags << {:wheelchair => 'no'}
+#   osm.save(@node)
+#
+module OpenStreetMap
+
+end

data/openstreetmap.gemspec

@@ -0,0 +1,53 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "openstreetmap"
+  s.version = "0.2.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Christoph B\u{fc}nte, Enno Brehm"]
+  s.date = "2012-03-22"
+  s.description = "OpenStreetMap API client for ruby"
+  s.email = ["info@christophbuente.de", "guildenstern@gmx.de"]
+  s.extra_rdoc_files = ["CHANGELOG", "LICENSE", "README.md", "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"]
+  s.files = ["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"]
+  s.homepage = "https://github.com/sozialhelden/openstreetmap"
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Openstreetmap", "--main", "README.md"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = "openstreetmap"
+  s.rubygems_version = "1.8.16"
+  s.summary = "OpenStreetMap API client for ruby"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<httparty>, [">= 0"])
+      s.add_runtime_dependency(%q<libxml-ruby>, [">= 0"])
+      s.add_runtime_dependency(%q<builder>, [">= 0"])
+      s.add_runtime_dependency(%q<oauth>, [">= 0"])
+      s.add_runtime_dependency(%q<activemodel>, [">= 0"])
+      s.add_development_dependency(%q<echoe>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+      s.add_development_dependency(%q<webmock>, [">= 0"])
+    else
+      s.add_dependency(%q<httparty>, [">= 0"])
+      s.add_dependency(%q<libxml-ruby>, [">= 0"])
+      s.add_dependency(%q<builder>, [">= 0"])
+      s.add_dependency(%q<oauth>, [">= 0"])
+      s.add_dependency(%q<activemodel>, [">= 0"])
+      s.add_dependency(%q<echoe>, [">= 0"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<webmock>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<httparty>, [">= 0"])
+    s.add_dependency(%q<libxml-ruby>, [">= 0"])
+    s.add_dependency(%q<builder>, [">= 0"])
+    s.add_dependency(%q<oauth>, [">= 0"])
+    s.add_dependency(%q<activemodel>, [">= 0"])
+    s.add_dependency(%q<echoe>, [">= 0"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<webmock>, [">= 0"])
+  end
+end

data/spec/open_street_map/changeset_spec.rb

@@ -0,0 +1,90 @@
+require 'openstreetmap'
+
+describe 'OpenStreetMap::Changeset' do
+
+  let :changeset do
+    OpenStreetMap::Changeset.new( :id => "123",
+                                  :user => "fred",
+                                  :uid => "123",
+                                  :created_at => "2008-11-08T19:07:39+01:00",
+                                  :open => "true",
+                                  :min_lat => "52.2",
+                                  :max_lat => "52.3",
+                                  :min_lon => "13.4",
+                                  :max_lon => "13.5")
+  end
+
+  it "should have an id attribute set from attributes" do
+    changeset.id.should eql(123)
+  end
+
+  it "should have an id attribute within xml representation" do
+    changeset.to_xml.should match /id=\"123\"/
+  end
+
+  it "should have a user attributes set from attributes" do
+    changeset.user.should eql("fred")
+  end
+
+  it "should have a user attribute within xml representation" do
+    changeset.to_xml.should match /user=\"fred\"/
+  end
+
+  it "should have an uid attribute set from attributes" do
+    changeset.uid.should eql(123)
+  end
+
+  it "should have an uid attribute within xml representation" do
+    changeset.to_xml.should match /uid=\"123\"/
+  end
+
+  it "should have a changeset attributes set from attributes" do
+    changeset.should be_open
+  end
+
+  it "should have an open attribute within xml representation" do
+    changeset.to_xml.should match /open=\"true\"/
+  end
+
+  it "should have a min_lat attribute set from attributes" do
+    changeset.min_lat.should eql(52.2)
+  end
+
+  it "should have a min_lat attribute within xml representation" do
+    changeset.to_xml.should match /min_lat=\"52.2\"/
+  end
+
+  it "should have a min_lon attribute set from attributes" do
+    changeset.min_lon.should eql(13.4)
+  end
+
+  it "should have a min_lon attribute within xml representation" do
+    changeset.to_xml.should match /min_lon=\"13.4\"/
+  end
+
+  it "should have a max_lat attribute set from attributes" do
+    changeset.max_lat.should eql(52.3)
+  end
+
+  it "should have a max_lat attribute within xml representation" do
+    changeset.to_xml.should match /max_lat=\"52.3\"/
+  end
+
+  it "should have a max_lon attribute set from attributes" do
+    changeset.max_lon.should eql(13.5)
+  end
+
+  it "should have a max_lon attribute within xml representation" do
+    changeset.to_xml.should match /max_lon=\"13.5\"/
+  end
+
+  it "should have a created_at attribute set from attributes" do
+    changeset.created_at.should eql Time.parse('2008-11-08T19:07:39+01:00')
+  end
+
+  it "should have a created_at attribute within xml representation" do
+    changeset.to_xml.should match /created_at=\"/
+  end
+
+
+end