Exclude:
- 'test/**/*'
+Metrics/ModuleLength:
+ Max: 150
+
Naming/FileName:
Exclude:
- 'script/deliver-message'
before_action :check_api_readable
around_action :api_call_handle_error, :api_call_timeout
+ before_action :set_default_request_format
+
# This is probably the most common call of all. It is used for getting the
# OSM data for a specified bounding box, usually for editing. First the
# bounding box (bbox) is checked to make sure that it is sane. All nodes
response.headers["Content-Disposition"] = "attachment; filename=\"map.osm\""
# Render the result
- render :formats => [:xml]
+ respond_to do |format|
+ format.xml
+ format.json
+ end
end
end
end
before_action :check_api_readable, :except => [:create, :update, :delete]
around_action :api_call_handle_error, :api_call_timeout
+ before_action :set_default_request_format, :except => [:create, :update, :delete]
+
# Create a node from XML.
def create
assert_method :put
if @node.visible
# Render the result
- render :formats => [:xml]
+ respond_to do |format|
+ format.xml
+ format.json
+ end
else
head :gone
end
@nodes = Node.find(ids)
# Render the result
- render :formats => [:xml]
+ respond_to do |format|
+ format.xml
+ format.json
+ end
end
end
end
before_action :lookup_old_element, :except => [:history]
before_action :lookup_old_element_versions, :only => [:history]
+ before_action :set_default_request_format, :except => [:redact]
+
def history
# the .where() method used in the lookup_old_element_versions
# call won't throw an error if no records are found, so we have
end
# Render the result
- render :formats => [:xml]
+ respond_to do |format|
+ format.xml
+ format.json
+ end
end
def version
response.last_modified = @old_element.timestamp
# Render the result
- render :formats => [:xml]
+ respond_to do |format|
+ format.xml
+ format.json
+ end
end
end
before_action :check_api_readable, :except => [:create, :update, :delete]
around_action :api_call_handle_error, :api_call_timeout
+ before_action :set_default_request_format, :except => [:create, :update, :delete]
+
def create
assert_method :put
response.last_modified = @relation.timestamp
if @relation.visible
# Render the result
- render :formats => [:xml]
+ respond_to do |format|
+ format.xml
+ format.json
+ end
else
head :gone
end
@relations << relation
# Render the result
- render :formats => [:xml]
+ respond_to do |format|
+ format.xml
+ format.json
+ end
else
head :gone
end
@relations = Relation.find(ids)
# Render the result
- render :formats => [:xml]
+ respond_to do |format|
+ format.xml
+ format.json
+ end
end
def relations_for_way
end
# Render the result
- render :formats => [:xml]
+ respond_to do |format|
+ format.xml
+ format.json
+ end
end
end
end
before_action :check_api_readable, :except => [:create, :update, :delete]
around_action :api_call_handle_error, :api_call_timeout
+ before_action :set_default_request_format, :except => [:create, :update, :delete]
+
def create
assert_method :put
if @way.visible
# Render the result
- render :formats => [:xml]
+ respond_to do |format|
+ format.xml
+ format.json
+ end
else
head :gone
end
end
# Render the result
- render :formats => [:xml]
+ respond_to do |format|
+ format.xml
+ format.json
+ end
else
head :gone
end
@ways = Way.find(ids)
# Render the result
- render :formats => [:xml]
+ respond_to do |format|
+ format.xml
+ format.json
+ end
end
##
@ways = Way.where(:id => wayids, :visible => true)
# Render the result
- render :formats => [:xml]
+ respond_to do |format|
+ format.xml
+ format.json
+ end
end
end
end
private
+ ##
+ # Set default request format to xml unless a client requests a specific format,
+ # which can be done via (a) URL suffix and/or (b) HTTP Accept header, where
+ # the URL suffix always takes precedence over the Accept header.
+ def set_default_request_format
+ unless params[:format]
+ accept_header = request.headers["HTTP_ACCEPT"]
+ if accept_header.nil?
+ # e.g. unit tests don't set an Accept: header by default, force XML in this case
+ request.format = "xml"
+ return
+ end
+
+ req_mimetypes = []
+
+ # Some clients (JOSM) send Accept headers which cannot be parsed by Rails, example: *; q=.2
+ # To be fair, JOSM's Accept header doesn't adhere to RFC 7231, section 5.3.1, et al. either
+ # As a workaround for backwards compatibility, we're assuming XML format
+ begin
+ req_mimetypes = Mime::Type.parse(accept_header)
+ rescue Mime::Type::InvalidMimeType
+ request.format = "xml"
+ return
+ end
+
+ # req_mimetypes contains all Accept header MIME types with descending priority
+ req_mimetypes.each do |mime|
+ if mime.symbol == :xml
+ request.format = "xml"
+ break
+ end
+
+ if mime.symbol == :json
+ request.format = "json"
+ break
+ end
+
+ # Any format, not explicitly requesting XML or JSON -> assume XML as default
+ if mime == "*/*"
+ request.format = "xml"
+ break
+ end
+
+ # In case the client requests some other format besides XML, JSON and */*,
+ # we deliberately don't set request.format. The framework will return an
+ # ActionController::UnknownFormat error to the client later on in this case.
+ end
+ end
+ end
+
def authorize(realm = "Web Password", errormessage = "Couldn't authenticate you")
# make the current_user object from any auth sources we have
setup_user_auth
def api_call_handle_error
yield
+ rescue ActionController::UnknownFormat
+ head :not_acceptable
rescue ActiveRecord::RecordNotFound => e
head :not_found
rescue LibXML::XML::Error, ArgumentError => e
link_to h(wmc[:title]), wmc[:url], :title => t("browse.tag_details.wikimedia_commons_link", :page => wmc[:title])
elsif url = wiki_link("tag", "#{key}=#{value}")
link_to h(value), url, :title => t("browse.tag_details.wiki_link.tag", :key => key, :value => value)
+ elsif email = email_link(key, value)
+ link_to(h(email[:email]), email[:url], :title => t("browse.tag_details.email_link", :email => email[:email]))
elsif phones = telephone_links(key, value)
# similarly, telephone_links() returns an array of phone numbers
phones = phones.map do |p|
nil
end
+ def email_link(_key, value)
+ # Does the value look like an email? eg "someone@domain.tld"
+
+ # Uses Ruby built-in regexp to validate email.
+ # This will not catch certain valid emails containing comments, whitespace characters,
+ # and quoted strings.
+ # (see: https://github.com/ruby/ruby/blob/master/lib/uri/mailto.rb)
+
+ # remove any leading and trailing whitespace
+ email = value.strip
+
+ if email.match?(URI::MailTo::EMAIL_REGEXP)
+ # add 'mailto:'' prefix
+ return { :email => email, :url => "mailto:#{email}" }
+ end
+
+ nil
+ end
+
def telephone_links(_key, value)
# Does it look like a global phone number? eg "+1 (234) 567-8901 "
# or a list of alternate numbers separated by ;
def to_s
format("%.7f", self)
end
+
+ def as_json(_)
+ format("%.7f", self).to_f
+ end
end
# This scaling factor is used to convert between the float lat/lon that is
--- /dev/null
+json.version Settings.api_version
+json.generator Settings.generator
+json.copyright Settings.copyright_owner
+json.attribution Settings.attribution_url
+json.license Settings.license_url
--- /dev/null
+json.bounds do
+ json.minlat GeoRecord::Coord.new(@bounds.min_lat)
+ json.minlon GeoRecord::Coord.new(@bounds.min_lon)
+ json.maxlat GeoRecord::Coord.new(@bounds.max_lat)
+ json.maxlon GeoRecord::Coord.new(@bounds.max_lon)
+end
--- /dev/null
+json.partial! "root_attributes"
+
+json.partial! "bounds"
+
+all = @nodes + @ways + @relations
+
+json.elements(all) do |obj|
+ json.partial! obj
+end
--- /dev/null
+json.type "node"
+json.id node.id
+if node.visible
+ json.lat GeoRecord::Coord.new(node.lat)
+ json.lon GeoRecord::Coord.new(node.lon)
+end
+json.timestamp node.timestamp.xmlschema
+json.version node.version
+json.changeset node.changeset_id
+json.user node.changeset.user.display_name
+json.uid node.changeset.user_id
+
+json.visible node.visible unless node.visible
+
+json.tags node.tags unless node.tags.empty?
--- /dev/null
+json.partial! "api/root_attributes"
+
+json.elements(@nodes) do |node|
+ json.partial! node
+end
--- /dev/null
+json.partial! "api/root_attributes"
+
+json.elements([@node]) do |node|
+ json.partial! node
+end
--- /dev/null
+json.type "node"
+json.id old_node.node_id
+if old_node.visible
+ json.lat GeoRecord::Coord.new(old_node.lat)
+ json.lon GeoRecord::Coord.new(old_node.lon)
+end
+json.timestamp old_node.timestamp.xmlschema
+json.version old_node.version
+json.changeset old_node.changeset_id
+json.user old_node.changeset.user.display_name
+json.uid old_node.changeset.user_id
+
+json.visible old_node.visible unless old_node.visible
+
+json.tags old_node.tags unless old_node.tags.empty?
--- /dev/null
+json.partial! "api/root_attributes"
+
+json.elements(@elems) do |old_node|
+ json.partial! old_node
+end
--- /dev/null
+json.partial! "api/root_attributes"
+
+json.elements([@old_element]) do |old_node|
+ json.partial! old_node
+end
--- /dev/null
+json.type "relation"
+json.id old_relation.relation_id
+json.timestamp old_relation.timestamp.xmlschema
+json.version old_relation.version
+json.changeset old_relation.changeset_id
+json.user old_relation.changeset.user.display_name
+json.uid old_relation.changeset.user_id
+
+json.visible old_relation.visible unless old_relation.visible
+
+unless old_relation.relation_members.empty?
+ json.members(old_relation.relation_members) do |m|
+ json.type m.member_type.downcase
+ json.ref m.member_id
+ json.role m.member_role
+ end
+end
+
+json.tags old_relation.tags unless old_relation.tags.empty?
--- /dev/null
+json.partial! "api/root_attributes"
+
+json.elements(@elems) do |old_relation|
+ json.partial! old_relation
+end
--- /dev/null
+json.partial! "api/root_attributes"
+
+json.elements([@old_element]) do |old_relation|
+ json.partial! old_relation
+end
--- /dev/null
+json.type "way"
+json.id old_way.way_id
+json.timestamp old_way.timestamp.xmlschema
+json.version old_way.version
+json.changeset old_way.changeset_id
+json.user old_way.changeset.user.display_name
+json.uid old_way.changeset.user_id
+
+json.visible old_way.visible unless old_way.visible
+
+json.nodes old_way.nds unless old_way.nds.empty?
+
+json.tags old_way.tags unless old_way.tags.empty?
--- /dev/null
+json.partial! "api/root_attributes"
+
+json.elements(@elems) do |old_way|
+ json.partial! old_way
+end
--- /dev/null
+json.partial! "api/root_attributes"
+
+json.elements([@old_element]) do |old_way|
+ json.partial! old_way
+end
--- /dev/null
+json.type "relation"
+json.id relation.id
+json.timestamp relation.timestamp.xmlschema
+json.version relation.version
+json.changeset relation.changeset_id
+json.user relation.changeset.user.display_name
+json.uid relation.changeset.user_id
+
+json.visible relation.visible unless relation.visible
+
+unless relation.relation_members.empty?
+ json.members(relation.relation_members) do |m|
+ json.type m.member_type.downcase
+ json.ref m.member_id
+ json.role m.member_role
+ end
+end
+
+json.tags relation.tags unless relation.tags.empty?
--- /dev/null
+json.partial! "api/root_attributes"
+
+all = @nodes + @ways + @relations
+
+json.elements(all) do |obj|
+ json.partial! obj
+end
--- /dev/null
+json.partial! "api/root_attributes"
+
+json.elements(@relations) do |relation|
+ json.partial! relation
+end
--- /dev/null
+json.partial! "api/root_attributes"
+
+json.elements(@relations) do |relation|
+ json.partial! relation
+end
--- /dev/null
+json.partial! "api/root_attributes"
+
+json.elements(@relations) do |relation|
+ json.partial! relation
+end
--- /dev/null
+json.partial! "api/root_attributes"
+
+json.elements(@relations) do |relation|
+ json.partial! relation
+end
--- /dev/null
+json.partial! "api/root_attributes"
+
+json.elements([@relation]) do |relation|
+ json.partial! relation
+end
--- /dev/null
+json.type "way"
+json.id way.id
+json.timestamp way.timestamp.xmlschema
+json.version way.version
+json.changeset way.changeset_id
+json.user way.changeset.user.display_name
+json.uid way.changeset.user_id
+
+json.visible way.visible unless way.visible
+
+json.nodes way.nodes.ids unless way.nodes.ids.empty?
+
+json.tags way.tags unless way.tags.empty?
--- /dev/null
+json.partial! "api/root_attributes"
+
+all = @nodes + [@way]
+
+json.elements(all) do |obj|
+ json.partial! obj
+end
--- /dev/null
+json.partial! "api/root_attributes"
+
+json.elements(@ways) do |way|
+ json.partial! way
+end
--- /dev/null
+json.partial! "api/root_attributes"
+
+json.elements([@way]) do |way|
+ json.partial! way
+end
--- /dev/null
+json.partial! "api/root_attributes"
+
+json.elements(@ways) do |way|
+ json.partial! way
+end
farmyard: landwirtschaftliche Betriebsfläche
forest: Wald
garages: Garagen
- grass: Wiese
+ grass: Gras
greenfield: unerschlossenes Bauland
industrial: Industriegebiet
landfill: Deponie
forest: Wald
geyser: Geysir
glacier: Gletscher
- grassland: Wiese
+ grassland: Grasland
heath: Heide
hill: Hügel
island: Insel
gpx_notification:
greeting: Hei!
your_gpx_file: Ylöslattaamasi GPX-fiili
- with_description: ', jonka kuvvaus on'
+ with_description: ', jonka kuvvaus oon'
failure:
failed_to_import: 'epäonnistui importeerata. Täsä virhe:'
more_info_1: Lissää tietoja GPX-importeerausongelmista ja miten niitä voi
title: Luodaan uusi redaktio
show:
description: 'Kuvvaus:'
- heading: Näytetään redaktio ”%{title}”
- title: Näytetään redaktio
+ heading: Näytethään redaktio ”%{title}”
+ title: Näytethään redaktio
user: 'Luoja:'
edit: Mookkaa tätä laitosta
destroy: Ota poies tämä redaktio
title: नियमहरू !
traces:
new:
- upload_gpx: 'GPX फाइल अपलोड गर्ने:'
+ upload_gpx: 'जिपिएक्स फाइल उर्ध्वभरण गर्नुहाेस्:'
description: 'विवरण:'
tags: ट्यागहरूः
tags_help: अल्पविरामले छुट्याएको
+BUNDLE ?= bundle
PG_CONFIG ?= pg_config
DESTDIR ?= .
-QTDIR=$(shell bundle show quad_tile | tail -n 1)/ext/quad_tile
+QTDIR=$(shell ${BUNDLE} show quad_tile | tail -n 1)/ext/quad_tile
OS=$(shell uname -s)
ifeq (${OS},Darwin)
{ :path => "/api/0.6/map", :method => :get },
{ :controller => "api/map", :action => "index" }
)
+ assert_routing(
+ { :path => "/api/0.6/map.json", :method => :get },
+ { :controller => "api/map", :action => "index", :format => "json" }
+ )
+ end
+
+ ##
+ # test http accept headers
+ def test_http_accept_header
+ node = create(:node)
+
+ minlon = node.lon - 0.1
+ minlat = node.lat - 0.1
+ maxlon = node.lon + 0.1
+ maxlat = node.lat + 0.1
+ bbox = "#{minlon},#{minlat},#{maxlon},#{maxlat}"
+
+ # Accept: XML format -> use XML
+ http_accept_format("text/xml")
+ get :index, :params => { :bbox => bbox }
+ assert_response :success, "Expected success with the map call"
+ assert_equal "application/xml; charset=utf-8", @response.header["Content-Type"]
+
+ # Accept: Any format -> use XML
+ http_accept_format("*/*")
+ get :index, :params => { :bbox => bbox }
+ assert_response :success, "Expected success with the map call"
+ assert_equal "application/xml; charset=utf-8", @response.header["Content-Type"]
+
+ # Accept: Any format, .json URL suffix -> use json
+ http_accept_format("*/*")
+ get :index, :params => { :bbox => bbox, :format => "json" }
+ assert_response :success, "Expected success with the map call"
+ assert_equal "application/json; charset=utf-8", @response.header["Content-Type"]
+
+ # Accept: Firefox header -> use XML
+ http_accept_format("text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8")
+ get :index, :params => { :bbox => bbox }
+ assert_response :success, "Expected success with the map call"
+ assert_equal "application/xml; charset=utf-8", @response.header["Content-Type"]
+
+ # Accept: JOSM header text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2 -> use XML
+ # Note: JOSM's header does not comply with RFC 7231, section 5.3.1
+ http_accept_format("text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2")
+ get :index, :params => { :bbox => bbox }
+ assert_response :success, "Expected success with the map call"
+ assert_equal "application/xml; charset=utf-8", @response.header["Content-Type"]
+
+ # Accept: text/plain, */* -> use XML
+ http_accept_format("text/plain, */*")
+ get :index, :params => { :bbox => bbox }
+ assert_response :success, "Expected success with the map call"
+ assert_equal "application/xml; charset=utf-8", @response.header["Content-Type"]
+
+ # Accept: text/* -> use XML
+ http_accept_format("text/*")
+ get :index, :params => { :bbox => bbox }
+ assert_response :success, "Expected success with the map call"
+ assert_equal "application/xml; charset=utf-8", @response.header["Content-Type"]
+
+ # Accept: json, */* format -> use json
+ http_accept_format("application/json, */*")
+ get :index, :params => { :bbox => bbox }
+ assert_response :success, "Expected success with the map call"
+ assert_equal "application/json; charset=utf-8", @response.header["Content-Type"]
+
+ # Accept: json format -> use json
+ http_accept_format("application/json")
+ get :index, :params => { :bbox => bbox }
+ assert_response :success, "Expected success with the map call"
+ assert_equal "application/json; charset=utf-8", @response.header["Content-Type"]
+
+ # text/json is in invalid format, return HTTP 406 Not acceptable
+ http_accept_format("text/json")
+ get :index, :params => { :bbox => bbox }
+ assert_response :not_acceptable, "text/json should fail"
+
+ # image/jpeg is a format which we don't support, return HTTP 406 Not acceptable
+ http_accept_format("image/jpeg")
+ get :index, :params => { :bbox => bbox }
+ assert_response :not_acceptable, "text/json should fail"
end
# -------------------------------------
end
end
+ def test_map_json
+ node = create(:node, :lat => 7, :lon => 7)
+ tag = create(:node_tag, :node => node)
+ way1 = create(:way_node, :node => node).way
+ way2 = create(:way_node, :node => node).way
+ relation = create(:relation_member, :member => node).relation
+
+ # Need to split the min/max lat/lon out into their own variables here
+ # so that we can test they are returned later.
+ minlon = node.lon - 0.1
+ minlat = node.lat - 0.1
+ maxlon = node.lon + 0.1
+ maxlat = node.lat + 0.1
+ bbox = "#{minlon},#{minlat},#{maxlon},#{maxlat}"
+ get :index, :params => { :bbox => bbox, :format => "json" }
+ if $VERBOSE
+ print @request.to_yaml
+ print @response.body
+ end
+ assert_response :success, "Expected success with the map call"
+ js = ActiveSupport::JSON.decode(@response.body)
+ assert_not_nil js
+
+ assert_equal Settings.api_version, js["version"]
+ assert_equal Settings.generator, js["generator"]
+ assert_equal GeoRecord::Coord.new(minlon), js["bounds"]["minlon"]
+ assert_equal GeoRecord::Coord.new(minlat), js["bounds"]["minlat"]
+ assert_equal GeoRecord::Coord.new(maxlon), js["bounds"]["maxlon"]
+ assert_equal GeoRecord::Coord.new(maxlat), js["bounds"]["maxlat"]
+
+ result_nodes = js["elements"].select { |a| a["type"] == "node" }
+ .select { |a| a["id"] == node.id }
+ .select { |a| a["lat"] == GeoRecord::Coord.new(node.lat) }
+ .select { |a| a["lon"] == GeoRecord::Coord.new(node.lon) }
+ .select { |a| a["version"] == node.version }
+ .select { |a| a["changeset"] == node.changeset_id }
+ .select { |a| a["timestamp"] == node.timestamp.xmlschema }
+ assert_equal result_nodes.count, 1
+ result_node = result_nodes.first
+
+ assert_equal result_node["tags"], tag.k => tag.v
+ assert_equal 2, (js["elements"].count { |a| a["type"] == "way" })
+ assert_equal 1, (js["elements"].count { |a| a["type"] == "way" && a["id"] == way1.id })
+ assert_equal 1, (js["elements"].count { |a| a["type"] == "way" && a["id"] == way2.id })
+ assert_equal 1, (js["elements"].count { |a| a["type"] == "relation" })
+ assert_equal 1, (js["elements"].count { |a| a["type"] == "relation" && a["id"] == relation.id })
+ end
+
# This differs from the above test in that we are making the bbox exactly
# the same as the node we are looking at
def test_map_inclusive
{ :path => "/api/0.6/node/1", :method => :get },
{ :controller => "api/nodes", :action => "show", :id => "1" }
)
+ assert_routing(
+ { :path => "/api/0.6/node/1.json", :method => :get },
+ { :controller => "api/nodes", :action => "show", :id => "1", :format => "json" }
+ )
assert_routing(
{ :path => "/api/0.6/node/1", :method => :put },
{ :controller => "api/nodes", :action => "update", :id => "1" }
{ :path => "/api/0.6/nodes", :method => :get },
{ :controller => "api/nodes", :action => "index" }
)
+ assert_routing(
+ { :path => "/api/0.6/nodes.json", :method => :get },
+ { :controller => "api/nodes", :action => "index", :format => "json" }
+ )
end
def test_create
assert_select "node[id='#{node5.id}'][visible='false']", :count => 1
end
+ # test a working call with json format
+ get :index, :params => { :nodes => "#{node1.id},#{node2.id},#{node3.id},#{node4.id},#{node5.id}", :format => "json" }
+
+ js = ActiveSupport::JSON.decode(@response.body)
+ assert_not_nil js
+ assert_equal 5, js["elements"].count
+ assert_equal 5, (js["elements"].count { |a| a["type"] == "node" })
+ assert_equal 1, (js["elements"].count { |a| a["id"] == node1.id && a["visible"].nil? })
+ assert_equal 1, (js["elements"].count { |a| a["id"] == node2.id && a["visible"] == false })
+ assert_equal 1, (js["elements"].count { |a| a["id"] == node3.id && a["visible"].nil? })
+ assert_equal 1, (js["elements"].count { |a| a["id"] == node4.id && a["visible"].nil? })
+ assert_equal 1, (js["elements"].count { |a| a["id"] == node5.id && a["visible"] == false })
+
# check error when a non-existent node is included
get :index, :params => { :nodes => "#{node1.id},#{node2.id},#{node3.id},#{node4.id},#{node5.id},0" }
assert_response :not_found
{ :path => "/api/0.6/node/1/2", :method => :get },
{ :controller => "api/old_nodes", :action => "version", :id => "1", :version => "2" }
)
+ assert_routing(
+ { :path => "/api/0.6/node/1/history.json", :method => :get },
+ { :controller => "api/old_nodes", :action => "history", :id => "1", :format => "json" }
+ )
+ assert_routing(
+ { :path => "/api/0.6/node/1/2.json", :method => :get },
+ { :controller => "api/old_nodes", :action => "version", :id => "1", :version => "2", :format => "json" }
+ )
assert_routing(
{ :path => "/api/0.6/node/1/2/redact", :method => :post },
{ :controller => "api/old_nodes", :action => "redact", :id => "1", :version => "2" }
{ :path => "/api/0.6/relation/1/2", :method => :get },
{ :controller => "api/old_relations", :action => "version", :id => "1", :version => "2" }
)
+ assert_routing(
+ { :path => "/api/0.6/relation/1/history.json", :method => :get },
+ { :controller => "api/old_relations", :action => "history", :id => "1", :format => "json" }
+ )
+ assert_routing(
+ { :path => "/api/0.6/relation/1/2.json", :method => :get },
+ { :controller => "api/old_relations", :action => "version", :id => "1", :version => "2", :format => "json" }
+ )
assert_routing(
{ :path => "/api/0.6/relation/1/2/redact", :method => :post },
{ :controller => "api/old_relations", :action => "redact", :id => "1", :version => "2" }
{ :path => "/api/0.6/way/1/2", :method => :get },
{ :controller => "api/old_ways", :action => "version", :id => "1", :version => "2" }
)
+ assert_routing(
+ { :path => "/api/0.6/way/1/history.json", :method => :get },
+ { :controller => "api/old_ways", :action => "history", :id => "1", :format => "json" }
+ )
+ assert_routing(
+ { :path => "/api/0.6/way/1/2.json", :method => :get },
+ { :controller => "api/old_ways", :action => "version", :id => "1", :version => "2", :format => "json" }
+ )
assert_routing(
{ :path => "/api/0.6/way/1/2/redact", :method => :post },
{ :controller => "api/old_ways", :action => "redact", :id => "1", :version => "2" }
{ :path => "/api/0.6/relation/1/full", :method => :get },
{ :controller => "api/relations", :action => "full", :id => "1" }
)
+ assert_routing(
+ { :path => "/api/0.6/relation/1/full.json", :method => :get },
+ { :controller => "api/relations", :action => "full", :id => "1", :format => "json" }
+ )
assert_routing(
{ :path => "/api/0.6/relation/1", :method => :get },
{ :controller => "api/relations", :action => "show", :id => "1" }
)
+ assert_routing(
+ { :path => "/api/0.6/relation/1.json", :method => :get },
+ { :controller => "api/relations", :action => "show", :id => "1", :format => "json" }
+ )
assert_routing(
{ :path => "/api/0.6/relation/1", :method => :put },
{ :controller => "api/relations", :action => "update", :id => "1" }
{ :path => "/api/0.6/relations", :method => :get },
{ :controller => "api/relations", :action => "index" }
)
+ assert_routing(
+ { :path => "/api/0.6/relations.json", :method => :get },
+ { :controller => "api/relations", :action => "index", :format => "json" }
+ )
assert_routing(
{ :path => "/api/0.6/node/1/relations", :method => :get },
{ :path => "/api/0.6/relation/1/relations", :method => :get },
{ :controller => "api/relations", :action => "relations_for_relation", :id => "1" }
)
+ assert_routing(
+ { :path => "/api/0.6/node/1/relations.json", :method => :get },
+ { :controller => "api/relations", :action => "relations_for_node", :id => "1", :format => "json" }
+ )
+ assert_routing(
+ { :path => "/api/0.6/way/1/relations.json", :method => :get },
+ { :controller => "api/relations", :action => "relations_for_way", :id => "1", :format => "json" }
+ )
+ assert_routing(
+ { :path => "/api/0.6/relation/1/relations.json", :method => :get },
+ { :controller => "api/relations", :action => "relations_for_relation", :id => "1", :format => "json" }
+ )
end
# -------------------------------------
assert_select "relation[id='#{relation4.id}'][visible='true']", :count => 1
end
+ # test a working call with json format
+ get :index, :params => { :relations => "#{relation1.id},#{relation2.id},#{relation3.id},#{relation4.id}", :format => "json" }
+
+ js = ActiveSupport::JSON.decode(@response.body)
+ assert_not_nil js
+ assert_equal 4, js["elements"].count
+ assert_equal 4, (js["elements"].count { |a| a["type"] == "relation" })
+ assert_equal 1, (js["elements"].count { |a| a["id"] == relation1.id && a["visible"].nil? })
+ assert_equal 1, (js["elements"].count { |a| a["id"] == relation2.id && a["visible"] == false })
+ assert_equal 1, (js["elements"].count { |a| a["id"] == relation3.id && a["visible"].nil? })
+ assert_equal 1, (js["elements"].count { |a| a["id"] == relation4.id && a["visible"].nil? })
+
# check error when a non-existent relation is included
get :index, :params => { :relations => "#{relation1.id},#{relation2.id},#{relation3.id},#{relation4.id},0" }
assert_response :not_found
{ :path => "/api/0.6/way/1/full", :method => :get },
{ :controller => "api/ways", :action => "full", :id => "1" }
)
+ assert_routing(
+ { :path => "/api/0.6/way/1/full.json", :method => :get },
+ { :controller => "api/ways", :action => "full", :id => "1", :format => "json" }
+ )
assert_routing(
{ :path => "/api/0.6/way/1", :method => :get },
{ :controller => "api/ways", :action => "show", :id => "1" }
)
+ assert_routing(
+ { :path => "/api/0.6/way/1.json", :method => :get },
+ { :controller => "api/ways", :action => "show", :id => "1", :format => "json" }
+ )
assert_routing(
{ :path => "/api/0.6/way/1", :method => :put },
{ :controller => "api/ways", :action => "update", :id => "1" }
{ :path => "/api/0.6/ways", :method => :get },
{ :controller => "api/ways", :action => "index" }
)
+ assert_routing(
+ { :path => "/api/0.6/ways.json", :method => :get },
+ { :controller => "api/ways", :action => "index", :format => "json" }
+ )
end
# -------------------------------------
assert_select "way[id='#{way4.id}'][visible='true']", :count => 1
end
+ # test a working call with json format
+ get :index, :params => { :ways => "#{way1.id},#{way2.id},#{way3.id},#{way4.id}", :format => "json" }
+
+ js = ActiveSupport::JSON.decode(@response.body)
+ assert_not_nil js
+ assert_equal 4, js["elements"].count
+ assert_equal 4, (js["elements"].count { |a| a["type"] == "way" })
+ assert_equal 1, (js["elements"].count { |a| a["id"] == way1.id && a["visible"].nil? })
+ assert_equal 1, (js["elements"].count { |a| a["id"] == way2.id && a["visible"] == false })
+ assert_equal 1, (js["elements"].count { |a| a["id"] == way3.id && a["visible"].nil? })
+ assert_equal 1, (js["elements"].count { |a| a["id"] == way4.id && a["visible"].nil? })
+
# check error when a non-existent way is included
get :index, :params => { :ways => "#{way1.id},#{way2.id},#{way3.id},#{way4.id},0" }
assert_response :not_found
assert_nil link
end
+ def test_email_link
+ email = email_link("foo", "Test")
+ assert_nil email
+
+ email = email_link("email", "123")
+ assert_nil email
+
+ email = email_link("email", "Abc.example.com")
+ assert_nil email
+
+ email = email_link("email", "a@b@c.com")
+ assert_nil email
+
+ email = email_link("email", "just\"not\"right@example.com")
+ assert_nil email
+
+ email = email_link("email", "123 abcdefg@space.com")
+ assert_nil email
+
+ email = email_link("email", "test@ abc")
+ assert_nil email
+
+ email = email_link("email", "using;semicolon@test.com")
+ assert_nil email
+
+ email = email_link("email", "x@example.com")
+ assert_equal "x@example.com", email[:email]
+ assert_equal "mailto:x@example.com", email[:url]
+
+ email = email_link("email", "other.email-with-hyphen@example.com")
+ assert_equal "other.email-with-hyphen@example.com", email[:email]
+ assert_equal "mailto:other.email-with-hyphen@example.com", email[:url]
+
+ email = email_link("email", "user.name+tag+sorting@example.com")
+ assert_equal "user.name+tag+sorting@example.com", email[:email]
+ assert_equal "mailto:user.name+tag+sorting@example.com", email[:url]
+
+ email = email_link("email", "dash-in@both-parts.com")
+ assert_equal "dash-in@both-parts.com", email[:email]
+ assert_equal "mailto:dash-in@both-parts.com", email[:url]
+
+ email = email_link("email", "example@s.example")
+ assert_equal "example@s.example", email[:email]
+ assert_equal "mailto:example@s.example", email[:url]
+
+ # Strips whitespace at ends
+ email = email_link("email", " test@email.com ")
+ assert_equal "test@email.com", email[:email]
+ assert_equal "mailto:test@email.com", email[:url]
+ end
+
def test_telephone_links
links = telephone_links("foo", "Test")
assert_nil links
@request.env["HTTP_AUTHORIZATION"] = format("Basic %{auth}", :auth => Base64.encode64("#{user}:#{pass}"))
end
+ ##
+ # set request header for HTTP Accept
+ def http_accept_format(format)
+ @request.env["HTTP_ACCEPT"] = format
+ end
+
##
# set request readers to ask for a particular error format
def error_format(format)
projects / rails.git / commitdiff