rosemary 0.2.2

data/lib/rosemary/element.rb

@@ -0,0 +1,280 @@
+module Rosemary
+  # This is a virtual parent class for the OSM objects Node, Way and Relation.
+  class Element
+    include ActiveModel::Validations
+
+    # Unique ID
+    attr_reader :id
+
+    # The version of this object (as read from file, it
+    # is not updated by operations to this object)
+    # API 0.6 and above only
+    attr_accessor :version
+
+    # 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
+
+    # Last change of this object (as read from file, it is not
+    # updated by operations to this object)
+    attr_reader :timestamp
+
+    # The changeset the last change of this object was made with.
+    attr_accessor :changeset
+
+    # Tags for this object
+    attr_reader :tags
+
+    # Get Rosemary::Element from API
+    def self.from_api(id, api=Rosemary::API.new) #:nodoc:
+        raise NotImplementedError.new('Element is a virtual base class for the Node, Way, and Relation classes') if self.class == Rosemary::Element
+        api.get_object(type, id)
+    end
+
+    def initialize(attrs = {}) #:nodoc:
+      raise NotImplementedError.new('Element is a virtual base class for the Node, Way, and Relation classes') if self.class == Rosemary::Element
+      attrs = {'version' => 1, 'uid' => 1}.merge(attrs.stringify_keys!)
+      @id         = attrs['id'].to_i if attrs['id']
+      @version    = attrs['version'].to_i
+      @uid        = attrs['uid'].to_i
+      @user       = attrs['user']
+      @timestamp  = Time.parse(attrs['timestamp']) rescue nil
+      @changeset  = attrs['changeset'].to_i
+      @tags       = Tags.new
+      add_tags(attrs['tag']) if attrs['tag']
+    end
+
+    # Create an error when somebody tries to set the ID.
+    # (We need this here because otherwise method_missing will be called.)
+    def id=(id) # :nodoc:
+      raise NotImplementedError.new('id can not be changed once the object was created')
+    end
+
+    # Set timestamp for this object.
+    def timestamp=(timestamp)
+      @timestamp = _check_timestamp(timestamp)
+    end
+
+    # The list of attributes for this object
+    def attribute_list # :nodoc:
+      [:id, :version, :uid, :user, :timestamp, :tags]
+    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
+
+    # Get tag value
+    def [](key)
+      tags[key]
+    end
+
+    # Set tag
+    def []=(key, value)
+      tags[key] = value
+    end
+
+    # Add one or more tags to this object.
+    #
+    # call-seq: add_tags(Hash) -> OsmObject
+    #
+    def add_tags(new_tags)
+      case new_tags
+      when Array # Called with an array
+        # Call recursively for each entry
+        new_tags.each do |tag_hash|
+          add_tags(tag_hash)
+        end
+      when Hash # Called with a hash
+        #check if it is weird {'k' => 'key', 'v' => 'value'} syntax
+        if (new_tags.size == 2 && new_tags.keys.include?('k') && new_tags.keys.include?('v'))
+          # call recursively with values from k and v keys.
+          add_tags({new_tags['k'] => new_tags['v']})
+        else
+          # OK, this seems to be a proper ruby hash with a single entry
+          new_tags.each do |k,v|
+            self.tags[k] = v
+          end
+        end
+      end
+      self    # return self so calls can be chained
+    end
+
+    def update_attributes(attribute_hash)
+      dirty = false
+      attribute_hash.each do |key,value|
+        if self.send(key).to_s != value.to_s
+          self.send("#{key}=", value.to_s)
+          dirty = true
+        end
+      end
+
+      puts "returning #{dirty}"
+      dirty
+    end
+
+
+    # Has this object any tags?
+    #
+    # call-seq: is_tagged?
+    #
+    def is_tagged?
+      ! @tags.empty?
+    end
+
+    # Create a new GeoRuby::Shp4r::ShpRecord with the geometry of
+    # this object and the given attributes.
+    #
+    # This only works if the GeoRuby library is included.
+    #
+    # geom:: Geometry
+    # attributes:: Hash with attributes
+    #
+    # call-seq: shape(attributes) -> GeoRuby::Shp4r::ShpRecord
+    #
+    # Example:
+    #   require 'rubygems'
+    #   require 'geo_ruby'
+    #   node = Node(nil, nil, nil, 7.84, 54.34)
+    #   g = node.point
+    #   node.shape(g, :type => 'Pharmacy', :name => 'Hyde Park Pharmacy')
+    #
+    def shape(geom, attributes)
+      fields = Hash.new
+      attributes.each do |key, value|
+        fields[key.to_s] = value
+      end
+      GeoRuby::Shp4r::ShpRecord.new(geom, fields)
+    end
+
+    # Get all relations from the API that have his object as members.
+    #
+    # The optional parameter is an Rosemary::API object. If none is specified
+    # the default OSM API is used.
+    #
+    # Returns an array of Relation objects or an empty array.
+    #
+    def get_relations_from_api(api=Rosemary::API.new)
+      api.get_relations_referring_to_object(type, self.id.to_i)
+    end
+
+    # Get the history of this object from the API.
+    #
+    # The optional parameter is an Rosemary::API object. If none is specified
+    # the default OSM API is used.
+    #
+    # Returns an array of Rosemary::Node, Rosemary::Way, or Rosemary::Relation objects
+    # with all the versions.
+    def get_history_from_api(api=Rosemary::API.new)
+      api.get_history(type, self.id.to_i)
+    end
+
+    # All other methods are mapped so its easy to access tags: For
+    # instance obj.name is the same as obj.tags['name']. This works
+    # for getting and setting tags.
+    #
+    #   node = Rosemary::Node.new
+    #   node.add_tags( 'highway' => 'residential', 'name' => 'Main Street' )
+    #   node.highway                   #=> 'residential'
+    #   node.highway = 'unclassified'  #=> 'unclassified'
+    #   node.name                      #=> 'Main Street'
+    #
+    # In addition methods of the form <tt>key?</tt> are used to
+    # check boolean tags. For instance +oneway+ can be 'true' or
+    # 'yes' or '1', all meaning the same.
+    #
+    #   way.oneway?
+    #
+    # will check this. It returns true if the value of this key is
+    # either 'true', 'yes' or '1'.
+    def method_missing(method, *args)
+      methodname = method.to_s
+      if methodname.slice(-1, 1) == '='
+        if args.size != 1
+          raise ArgumentError.new("wrong number of arguments (#{args.size} for 1)")
+        end
+        tags[methodname.chop] = args[0]
+      elsif methodname.slice(-1, 1) == '?'
+        if args.size != 0
+          raise ArgumentError.new("wrong number of arguments (#{args.size} for 0)")
+        end
+        tags[methodname.chop] =~ /^(true|yes|1)$/
+      else
+        if args.size != 0
+          raise ArgumentError.new("wrong number of arguments (#{args.size} for 0)")
+        end
+        tags[methodname]
+      end
+    end
+
+    def initialize_copy(from)
+      super
+      @tags = from.tags.dup
+    end
+
+    private
+
+    # Return next free ID
+    def _next_id
+        @@id -= 1
+        @@id
+    end
+
+    def _check_id(id)
+        if id.kind_of?(Integer)
+            return id
+        elsif id.kind_of?(String)
+            raise ArgumentError, "ID must be an integer" unless id =~ /^-?[0-9]+$/
+            return id.to_i
+        else
+            raise ArgumentError, "ID must be integer or string with integer"
+        end
+    end
+
+    def _check_timestamp(timestamp)
+        if timestamp !~ /^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(Z|([+-][0-9]{2}:[0-9]{2}))$/
+            raise ArgumentError, "Timestamp is in wrong format (must be 'yyyy-mm-ddThh:mm:ss(Z|[+-]mm:ss)')"
+        end
+        timestamp
+    end
+
+    def _check_lon(lon)
+        if lon.kind_of?(Numeric)
+            return lon.to_s
+        elsif lon.kind_of?(String)
+            return lon
+        else
+            raise ArgumentError, "'lon' must be number or string containing number"
+        end
+    end
+
+    def _check_lat(lat)
+        if lat.kind_of?(Numeric)
+            return lat.to_s
+        elsif lat.kind_of?(String)
+            return lat
+        else
+            raise ArgumentError, "'lat' must be number or string containing number"
+        end
+    end
+
+  end
+end

data/lib/rosemary/errors.rb

@@ -0,0 +1,55 @@
+module Rosemary
+  # Unspecified OSM API error.
+  class Error < StandardError
+    attr_reader :data
+
+    def initialize(data)
+      @data = data
+      super
+    end
+  end
+
+  # This error occurs when Rosemary is instantiated without a client
+  class CredentialsMissing < StandardError; end
+
+  # This error occurs when Rosemary has no changeset.
+  class ChangesetMissing < StandardError; end
+
+  # An object was not found in the database.
+  class NotFound < Error; end
+
+  # The API returned HTTP 400 (Bad Request).
+  class BadRequest < Error; end # 400
+
+  # The API operation wasn't authorized. This happens if you didn't set the user and
+  # password for a write operation.
+  class Unauthorized < Error; end # 401
+
+  # The object was not found (HTTP 404). Generally means that the object doesn't exist
+  # and never has.
+  class NotFound < Error; end # 404
+
+  # If the request is not a HTTP PUT request
+  class MethodNotAllowed < Error; end # 405
+
+  # If the changeset in question has already been closed
+  class Conflict < Error; end # 409
+
+  # The object was not found (HTTP 410), but it used to exist. This generally means
+  # that the object existed at some point, but was deleted.
+  class Gone < Error; end # 410
+
+  # When a node is still used by a way
+  # When a node is still member of a relation
+  # When a way is still member of a relation
+  # When a relation is still member of another relation
+  class Precondition < Error; end # 412
+
+  # Unspecified API server error.
+  class ServerError < Error; end # 500
+
+  class Unavailable < Error; end # 503
+
+  class NotImplemented < Error; end # This method is not implemented yet.
+
+end

data/lib/rosemary/member.rb

@@ -0,0 +1,39 @@
+require 'builder'
+module Rosemary
+  # A member of an OpenStreetMap Relation.
+  class Member
+
+    # Role this member has in the relationship
+    attr_accessor :role
+
+    # Type of referenced object (can be 'node', 'way', or 'relation')
+    attr_reader :type
+
+    # ID of referenced object
+    attr_reader :ref
+
+    # Create a new Member object. Type can be one of 'node', 'way' or
+    # 'relation'. Ref is the ID of the corresponding Node, Way, or
+    # Relation. Role is a freeform string and can be empty.
+    def initialize(type, ref, role='')
+      if type !~ /^(node|way|relation)$/
+        raise ArgumentError.new("type must be 'node', 'way', or 'relation'")
+      end
+      if ref.to_s !~ /^[0-9]+$/
+          raise ArgumentError
+      end
+      @type = type
+      @ref  = ref.to_i
+      @role = role
+    end
+
+    # Return XML for this way. 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]
+      xml.member(:type => type, :ref => ref, :role => role)
+    end
+
+  end
+end

data/lib/rosemary/node.rb

@@ -0,0 +1,51 @@
+require 'builder'
+module Rosemary
+  # OpenStreetMap Node.
+  #
+  # To create a new Rosemary::Node object:
+  #   node = Rosemary::Node.new(:id => "123", :lat => "52.2", :lon => "13.4", :changeset => "12", :user => "fred", :uid => "123", :visible => true, :timestamp => "2005-07-30T14:27:12+01:00")
+  #
+  # To get a node from the API:
+  #   node = Rosemary::Node.find(17)
+  #
+  class Node < Element
+    # Longitude in decimal degrees
+    attr_accessor :lon
+
+    # Latitude in decimal degrees
+    attr_accessor :lat
+
+    validates :lat, :presence => true, :numericality => {:greater_than_or_equal_to => -180, :less_than_or_equal_to => 180}
+    validates :lon, :presence => true, :numericality => {:greater_than_or_equal_to => -90,  :less_than_or_equal_to => 90}
+
+    # Create new Node object.
+    #
+    # If +id+ is +nil+ a new unique negative ID will be allocated.
+    def initialize(attrs = {})
+      attrs.stringify_keys!
+      @lon = attrs['lon'].to_f rescue nil
+      @lat = attrs['lat'].to_f rescue nil
+      super(attrs)
+    end
+
+    def type
+      'Node'
+    end
+
+    # List of attributes for a Node
+    def attribute_list
+      [:id, :version, :uid, :user, :timestamp, :lon, :lat, :changeset]
+    end
+
+    def to_xml(options = {})
+      xml = options[:builder] ||= Builder::XmlMarkup.new
+      xml.instruct! unless options[:skip_instruct]
+      xml.osm do
+        xml.node(attributes) do
+          tags.to_xml(:builder => xml, :skip_instruct => true)
+        end
+      end
+    end
+
+  end
+end

data/lib/rosemary/oauth_client.rb

@@ -0,0 +1,31 @@
+module Rosemary
+  class OauthClient
+
+    attr_reader :access_token
+
+    def initialize(access_token)
+      @access_token = access_token
+    end
+
+    def get(url, header={})
+      access_token.get(url, {'Content-Type' => 'application/xml' })
+    end
+
+    def put(url, options={}, header={})
+      body = options[:body]
+      access_token.put(url, body, {'Content-Type' => 'application/xml' })
+    end
+
+    def delete(url, options={}, header={})
+      raise NotImplemented.new("Delete with Oauth and OSM is not supported")
+      # body = options[:body]
+      # access_token.delete(url, {'Content-Type' => 'application/xml' })
+    end
+
+    def post(url, options={}, header={})
+      body = options[:body]
+      access_token.post(url, body, {'Content-Type' => 'application/xml' })
+    end
+
+  end
+end

data/lib/rosemary/parser.rb

@@ -0,0 +1,123 @@
+require 'httparty'
+require 'xml/libxml'
+class Rosemary::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 == 'Rosemary::User'
+      if @description
+        @context.description = chars
+      end
+      if @lang
+        @context.languages << chars
+      end
+    end
+  end
+
+  private
+
+  def _start_node(attr_hash)
+    @context = Rosemary::Node.new(attr_hash)
+  end
+
+  def _start_way(attr_hash)
+    @context = Rosemary::Way.new(attr_hash)
+  end
+
+  def _start_relation(attr_hash)
+    @context = Rosemary::Relation.new(attr_hash)
+  end
+
+  def _start_changeset(attr_hash)
+    @context = Rosemary::Changeset.new(attr_hash)
+  end
+
+  def _end_changeset
+    @collection << @context
+  end
+
+  def _start_user(attr_hash)
+    @context = Rosemary::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 = Rosemary::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/rosemary/relation.rb

@@ -0,0 +1,52 @@
+module Rosemary
+  # OpenStreetMap Relation.
+  #
+  # To create a new Rosemary::Relation object:
+  #   relation = Rosemary::Relation.new()
+  #
+  # To get a relation from the API:
+  #   relation = Rosemary::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 = "Rosemary::#{member['type'].classify}".constantize
+        memo << class_to_instantize.new(:id => member['ref'])
+      end
+    end
+
+  end
+end

data/lib/rosemary/tags.rb

@@ -0,0 +1,26 @@
+module Rosemary
+  # 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/rosemary/user.rb

@@ -0,0 +1,34 @@
+require 'builder'
+module Rosemary
+  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/rosemary/version.rb

@@ -0,0 +1,3 @@
+module Rosemary
+  VERSION = "0.2.2"
+end