Refactoring

app/controllers/api/map_controller.rb

@@ -19,15 +19,15 @@ module Api
       # check boundary is sane and area within defined
       # see /config/application.yml
       begin
-        bbox = BoundingBox.from_bbox_params(params)
+        @bounds = BoundingBox.from_bbox_params(params)
-        bbox.check_boundaries
+        @bounds.check_boundaries
-        bbox.check_size
+        @bounds.check_size
       rescue StandardError => err
         report_error(err.message)
         return
       end
 
-      nodes = Node.bbox(bbox).where(:visible => true).includes(:node_tags).limit(Settings.max_number_of_nodes + 1)
+      nodes = Node.bbox(@bounds).where(:visible => true).includes(:node_tags).limit(Settings.max_number_of_nodes + 1)
 
       node_ids = nodes.collect(&:id)
       if node_ids.length > Settings.max_number_of_nodes
@@ -35,9 +35,6 @@ module Api
         return
       end
 
-      # add bounds
-      @bounds = bbox
-
       # get ways
       # find which ways are needed
       ways = []
@@ -77,22 +74,19 @@ module Api
         end
       end
 
-      relations = Relation.nodes(visible_nodes.keys).visible +
+      @relations = Relation.nodes(visible_nodes.keys).visible +
-                  Relation.ways(way_ids).visible
+                   Relation.ways(way_ids).visible
 
       # we do not normally return the "other" partners referenced by an relation,
       # e.g. if we return a way A that is referenced by relation X, and there's
       # another way B also referenced, that is not returned. But we do make
       # an exception for cases where an relation references another *relation*;
       # in that case we return that as well (but we don't go recursive here)
-      relations += Relation.relations(relations.collect(&:id)).visible
+      @relations += Relation.relations(@relations.collect(&:id)).visible
 
       # this "uniq" may be slightly inefficient; it may be better to first collect and output
       # all node-related relations, then find the *not yet covered* way-related ones etc.
-      @relations = []
+      @relations.uniq!
-      relations.uniq.each do |relation|
-        @relations << relation
-      end
 
       response.headers["Content-Disposition"] = "attachment; filename=\"map.osm\""
       # Render the result

app/controllers/api/nodes_controller.rb

@@ -26,13 +26,11 @@ module Api
 
     # Dump the details on a node given in params[:id]
     def show
-      node = Node.find(params[:id])
+      @node = Node.find(params[:id])
 
-      response.last_modified = node.timestamp
+      response.last_modified = @node.timestamp
-
-      if node.visible
-        @node = node
 
+      if @node.visible
         # Render the result
         respond_to do |format|
           format.xml

app/controllers/api/old_controller.rb

@@ -22,13 +22,12 @@ module Api
       # to do that ourselves.
       raise OSM::APINotFoundError if @elements.empty?
 
-      visible_elements = if show_redactions?
+      # determine visible elements
-                           @elements
+      @elems = if show_redactions?
-                         else
+                 @elements
-                           @elements.unredacted
+               else
-                         end
+                 @elements.unredacted
-
+               end
-      @elems = visible_elements
 
       # Render the result
       respond_to do |format|

app/controllers/api/relations_controller.rb

@@ -22,11 +22,9 @@ module Api
     end
 
     def show
-      relation = Relation.find(params[:id])
+      @relation = Relation.find(params[:id])
-      response.last_modified = relation.timestamp
+      response.last_modified = @relation.timestamp
-      if relation.visible
+      if @relation.visible
-        @relation = relation
-
         # Render the result
         respond_to do |format|
           format.xml

app/controllers/api/ways_controller.rb

@@ -22,13 +22,11 @@ module Api
     end
 
     def show
-      way = Way.find(params[:id])
+      @way = Way.find(params[:id])
 
-      response.last_modified = way.timestamp
+      response.last_modified = @way.timestamp
-
-      if way.visible
-        @way = way
 
+      if @way.visible
         # Render the result
         respond_to do |format|
           format.xml
@@ -64,22 +62,20 @@ module Api
     end
 
     def full
-      way = Way.includes(:nodes => :node_tags).find(params[:id])
+      @way = Way.includes(:nodes => :node_tags).find(params[:id])
 
-      if way.visible
+      if @way.visible
         visible_nodes = {}
 
         @nodes = []
 
-        way.nodes.uniq.each do |node|
+        @way.nodes.uniq.each do |node|
           if node.visible
             @nodes << node
             visible_nodes[node.id] = node
           end
         end
 
-        @way = way
-
         # Render the result
         respond_to do |format|
           format.xml