Localisation updates from translatewiki.net (2009-12-03)

[rails.git] / lib / diff_reader.rb

diff --git a/lib/diff_reader.rb b/lib/diff_reader.rb
index f7c51d79704fbd036a7ff45ec26fbf41922c35d6..0b159315830e25a6eb6c56c98c2295fbcac3ee36 100644 (file)
--- a/lib/diff_reader.rb
+++ b/lib/diff_reader.rb
@@ -18,10 +18,23 @@ class DiffReader
   # in OsmChange format. All diffs must be limited to a single changeset
   # given in +changeset+.
   def initialize(data, changeset)
   # in OsmChange format. All diffs must be limited to a single changeset
   # given in +changeset+.
   def initialize(data, changeset)

-    @reader = XML::Reader.new data
+    @reader = XML::Reader.string(data)

     @changeset = changeset
   end
 
     @changeset = changeset
   end
 

+  ##
+  # Reads the next element from the XML document. Checks the return value
+  # and throws an exception if an error occurred.
+  def read_or_die
+    # NOTE: XML::Reader#read returns false for EOF and raises an
+    # exception if an error occurs.
+    begin
+      @reader.read
+    rescue LibXML::XML::Error => ex
+      raise OSM::APIBadXMLError.new("changeset", xml, ex.message)
+    end
+  end
+

   ##
   # An element-block mapping for using the LibXML reader interface. 
   #
   ##
   # An element-block mapping for using the LibXML reader interface. 
   #


@@ -29,15 +42,25 @@ class DiffReader
   # elements, it would be better to DRY and do this in a block. This
   # could also help with error handling...?
   def with_element
   # elements, it would be better to DRY and do this in a block. This
   # could also help with error handling...?
   def with_element

-    # skip the first element, which is our opening element of the block
-    @reader.read
-    # loop over all elements. 
-    # NOTE: XML::Reader#read returns 0 for EOF and -1 for error.
-    while @reader.read == 1
-      break if @reader.node_type == 15 # end element
-      next unless @reader.node_type == 1 # element
-      yield @reader.name
+    # if the start element is empty then don't do any processing, as
+    # there won't be any child elements to process!
+    unless @reader.empty_element?
+      # read the first element
+      read_or_die
+
+      while @reader.node_type != 15 do # end element
+        # because we read elements in DOM-style to reuse their DOM
+        # parsing code, we don't always read an element on each pass
+        # as the call to @reader.next in the innermost loop will take
+        # care of that for us.
+        if @reader.node_type == 1 # element
+          yield @reader.name
+        else
+          read_or_die
+        end
+      end 

     end
     end

+    read_or_die

   end
 
   ##
   end
 
   ##


@@ -49,8 +72,8 @@ class DiffReader
   def with_model
     with_element do |model_name|
       model = MODELS[model_name]
   def with_model
     with_element do |model_name|
       model = MODELS[model_name]

-      raise "Unexpected element type #{model_name}, " +
-        "expected node, way, relation." if model.nil?
+      raise OSM::APIBadUserInput.new("Unexpected element type #{model_name}, " +
+                                     "expected node, way or relation.") if model.nil?

       yield model, @reader.expand
       @reader.next
     end
       yield model, @reader.expand
       @reader.next
     end


@@ -75,13 +98,18 @@ class DiffReader
   # an exception subclassing OSM::APIError will be thrown.
   def commit
 
   # an exception subclassing OSM::APIError will be thrown.
   def commit
 

+    # data structure used for mapping placeholder IDs to real IDs

     node_ids, way_ids, rel_ids = {}, {}, {}
     ids = { :node => node_ids, :way => way_ids, :relation => rel_ids}
 
     node_ids, way_ids, rel_ids = {}, {}, {}
     ids = { :node => node_ids, :way => way_ids, :relation => rel_ids}
 

+    # take the first element and check that it is an osmChange element
+    @reader.read
+    raise APIBadUserInput.new("Document element should be 'osmChange'.") if @reader.name != 'osmChange'
+

     result = OSM::API.new.get_xml_doc
     result = OSM::API.new.get_xml_doc

+    result.root.name = "diffResult"

 
 

-    # loop at the top level, within the <osmChange> element (although we
-    # don't actually check this...)
+    # loop at the top level, within the <osmChange> element

     with_element do |action_name|
       if action_name == 'create'
         # create a new element. this code is agnostic of the element type
     with_element do |action_name|
       if action_name == 'create'
         # create a new element. this code is agnostic of the element type


@@ -95,15 +123,20 @@ class DiffReader
           placeholder_id = xml['id'].to_i
           raise OSM::APIBadXMLError.new(model, xml) if placeholder_id.nil?
 
           placeholder_id = xml['id'].to_i
           raise OSM::APIBadXMLError.new(model, xml) if placeholder_id.nil?
 

+          # check if the placeholder ID has been given before and throw
+          # an exception if it has - we can't create the same element twice.
+          model_sym = model.to_s.downcase.to_sym
+          raise OSM::APIBadUserInput.new("Placeholder IDs must be unique for created elements.") if ids[model_sym].include? placeholder_id
+

           # some elements may have placeholders for other elements in the
           # diff, so we must fix these before saving the element.
           # some elements may have placeholders for other elements in the
           # diff, so we must fix these before saving the element.

-          new.fix_placeholders!(ids)
+          new.fix_placeholders!(ids, placeholder_id)

 
           # create element given user
           new.create_with_history(@changeset.user)
           
           # save placeholder => allocated ID map
 
           # create element given user
           new.create_with_history(@changeset.user)
           
           # save placeholder => allocated ID map

-          ids[model.to_s.downcase.to_sym][placeholder_id] = new.id
+          ids[model_sym][placeholder_id] = new.id

 
           # add the result to the document we're building for return.
           xml_result = XML::Node.new model.to_s.downcase
 
           # add the result to the document we're building for return.
           xml_result = XML::Node.new model.to_s.downcase


@@ -121,15 +154,24 @@ class DiffReader
           new = model.from_xml_node(xml, false)
           check(model, xml, new)
 
           new = model.from_xml_node(xml, false)
           check(model, xml, new)
 

+          # if the ID is a placeholder then map it to the real ID
+          model_sym = model.to_s.downcase.to_sym
+          client_id = new.id
+          is_placeholder = ids[model_sym].include? client_id
+          id = is_placeholder ? ids[model_sym][client_id] : client_id
+

           # and the old one from the database
           # and the old one from the database

-          old = model.find(new.id)
+          old = model.find(id)

 
 

+          # translate any placeholder IDs to their true IDs.

           new.fix_placeholders!(ids)
           new.fix_placeholders!(ids)

+          new.id = id
+

           old.update_from(new, @changeset.user)
 
           xml_result = XML::Node.new model.to_s.downcase
           old.update_from(new, @changeset.user)
 
           xml_result = XML::Node.new model.to_s.downcase

-          xml_result["old_id"] = old.id.to_s
-          xml_result["new_id"] = new.id.to_s 
+          xml_result["old_id"] = client_id.to_s
+          xml_result["new_id"] = id.to_s 

           # version is updated in "old" through the update, so we must not
           # return new.version here but old.version!
           xml_result["new_version"] = old.version.to_s
           # version is updated in "old" through the update, so we must not
           # return new.version here but old.version!
           xml_result["new_version"] = old.version.to_s


@@ -140,10 +182,24 @@ class DiffReader
         # delete action. this takes a payload in API 0.6, so we need to do
         # most of the same checks that are done for the modify.
         with_model do |model, xml|
         # delete action. this takes a payload in API 0.6, so we need to do
         # most of the same checks that are done for the modify.
         with_model do |model, xml|

-          new = model.from_xml_node(xml, false)
+          # delete doesn't have to contain a full payload, according to
+          # the wiki docs, so we just extract the things we need.
+          new_id = xml['id'].to_i
+          raise API::APIBadXMLError.new(model, xml, "ID attribute is required") if new_id.nil?
+
+          # if the ID is a placeholder then map it to the real ID
+          model_sym = model.to_s.downcase.to_sym
+          is_placeholder = ids[model_sym].include? new_id
+          id = is_placeholder ? ids[model_sym][new_id] : new_id
+
+          # build the "new" element by modifying the existing one
+          new = model.find(id)
+          new.changeset_id = xml['changeset'].to_i
+          new.version = xml['version'].to_i

           check(model, xml, new)
 
           check(model, xml, new)
 

-          old = model.find(new.id)
+          # fetch the matching old element from the DB
+          old = model.find(id)

 
           # can a delete have placeholders under any circumstances?
           # if a way is modified, then deleted is that a valid diff?
 
           # can a delete have placeholders under any circumstances?
           # if a way is modified, then deleted is that a valid diff?


@@ -151,7 +207,9 @@ class DiffReader
           old.delete_with_history!(new, @changeset.user)
 
           xml_result = XML::Node.new model.to_s.downcase
           old.delete_with_history!(new, @changeset.user)
 
           xml_result = XML::Node.new model.to_s.downcase

-          xml_result["old_id"] = old.id.to_s
+          # oh, the irony... the "new" element actually contains the "old" ID
+          # a better name would have been client/server, but anyway...
+          xml_result["old_id"] = new_id.to_s

           result.root << xml_result
         end
 
           result.root << xml_result
         end