gds-api-adapters 38.0.0 → 38.1.0

data/lib/gds_api/govuk_headers.rb

@@ -6,7 +6,7 @@ module GdsApi
       end
 
       def headers
-        header_data.select {|k, v| !(v.nil? || v.empty?) }
+        header_data.select { |_k, v| !(v.nil? || v.empty?) }
       end
 
       def clear_headers

data/lib/gds_api/imminence.rb

@@ -1,20 +1,19 @@
 require_relative 'base'
 
 class GdsApi::Imminence < GdsApi::Base
-
   def api_url(type, params)
-    vals = [:limit, :lat, :lng, :postcode].select{ |p| params.include? p }
+    vals = [:limit, :lat, :lng, :postcode].select { |p| params.include? p }
     querystring = URI.encode_www_form vals.map { |p| [p, params[p]] }
     "#{@endpoint}/places/#{type}.json?#{querystring}"
   end
 
-  def places(type, lat, lon, limit=5)
+  def places(type, lat, lon, limit = 5)
     url = api_url(type, lat: lat, lng: lon, limit: limit)
     places = get_json(url) || []
     places.map { |p| self.class.parse_place_hash(p) }
   end
 
-  def places_for_postcode(type, postcode, limit=5)
+  def places_for_postcode(type, postcode, limit = 5)
     url = api_url(type, postcode: postcode, limit: limit)
     places = get_json(url) || []
     places.map { |p| self.class.parse_place_hash(p) }
@@ -41,27 +40,27 @@ class GdsApi::Imminence < GdsApi::Base
     get_json(url)
   end
 
-private
+  # @private
   def self.extract_location_hash(location)
     # Deal with all known location formats:
     #   Old style: [latitude, longitude]; empty array for no location
     #   New style: hash with keys "longitude", "latitude"; nil for no location
     case location
     when Array
-      {"latitude" => location[0], "longitude" => location[1]}
+      { "latitude" => location[0], "longitude" => location[1] }
     when Hash
       location
     when nil
-      {"latitude" => nil, "longitude" => nil}
+      { "latitude" => nil, "longitude" => nil }
     end
   end
 
+  # @private
   def self.extract_address_hash(place_hash)
     address_fields = [
       place_hash["address1"],
       place_hash["address2"]
-    ].reject { |a| a.nil? or a == "" }
-    {"address" => address_fields.map(&:strip).join(", ")}
+    ].reject { |a| a.nil? || a == "" }
+    { "address" => address_fields.map(&:strip).join(", ") }
   end
-
 end

data/lib/gds_api/json_client.rb

@@ -9,7 +9,6 @@ require 'null_logger'
 
 module GdsApi
   class JsonClient
-
     include GdsApi::ExceptionHandling
 
     # Cache TTL will be overridden for a given request/response by the Expires
@@ -17,7 +16,7 @@ module GdsApi
     #
     # LRUCache doesn't respect a cache size of 0, and instead effectively
     # creates a cache with a size of 1.
-    def self.cache(size=DEFAULT_CACHE_SIZE, ttl=DEFAULT_CACHE_TTL)
+    def self.cache(size = DEFAULT_CACHE_SIZE, ttl = DEFAULT_CACHE_TTL)
       @cache ||= LRUCache.new(max_size: size, ttl: ttl)
     end
 
@@ -28,14 +27,14 @@ module GdsApi
     #   []=(key, value)
     #   store(key, value, expiry_time=nil) - or a Ruby Time object
     #
-    def self.cache=(c)
-      @cache = c
+    class << self
+      attr_writer :cache
     end
 
     attr_accessor :logger, :options, :cache
 
     def initialize(options = {})
-      if options[:disable_timeout] or options[:timeout].to_i < 0
+      if options[:disable_timeout] || options[:timeout].to_i < 0
         raise "It is no longer possible to disable the timeout."
       end
 
@@ -55,7 +54,7 @@ module GdsApi
       {
         'Accept' => 'application/json',
         # GOVUK_APP_NAME is set for all apps by Puppet
-        'User-Agent' => "gds-api-adapters/#{GdsApi::VERSION} (#{ENV["GOVUK_APP_NAME"]})"
+        'User-Agent' => "gds-api-adapters/#{GdsApi::VERSION} (#{ENV['GOVUK_APP_NAME']})"
       }
     end
 
@@ -77,35 +76,23 @@ module GdsApi
       get_raw!(url)
     end
 
-    # Define "safe" methods for each supported HTTP method
-    #
-    # Each "bang method" tries to make a request, but raises an exception if
-    # the response is not successful. These methods discard the HTTPNotFound
-    # exceptions (and return nil), and pass through all other exceptions.
-    [:get, :post, :put, :patch, :delete].each do |http_method|
-      method_name = "#{http_method}_json"
-      define_method method_name do |url, *args, &block|
-        send (method_name + "!"), url, *args, &block
-      end
-    end
-
-    def get_json!(url, additional_headers = {}, &create_response)
+    def get_json(url, additional_headers = {}, &create_response)
       do_json_request(:get, url, nil, additional_headers, &create_response)
     end
 
-    def post_json!(url, params = {}, additional_headers = {})
+    def post_json(url, params = {}, additional_headers = {})
       do_json_request(:post, url, params, additional_headers)
     end
 
-    def put_json!(url, params, additional_headers = {})
+    def put_json(url, params, additional_headers = {})
       do_json_request(:put, url, params, additional_headers)
     end
 
-    def patch_json!(url, params, additional_headers = {})
+    def patch_json(url, params, additional_headers = {})
       do_json_request(:patch, url, params, additional_headers)
     end
 
-    def delete_json!(url, additional_headers = {})
+    def delete_json(url, additional_headers = {})
       do_json_request(:delete, url, nil, additional_headers)
     end
 
@@ -122,22 +109,19 @@ module GdsApi
     end
 
     def post_multipart(url, params)
-      r = do_raw_request(:post, url, params.merge({
-        :multipart => true
-      }))
+      r = do_raw_request(:post, url, params.merge(multipart: true))
       Response.new(r)
     end
 
     def put_multipart(url, params)
-      r = do_raw_request(:put, url, params.merge({
-        :multipart => true
-      }))
+      r = do_raw_request(:put, url, params.merge(multipart: true))
       Response.new(r)
     end
 
-    private
+  private
+
     def do_raw_request(method, url, params = nil)
-      response = do_request(method, url, params)
+      do_request(method, url, params)
     rescue RestClient::Exception => e
       raise build_specific_http_error(e, url, nil, params)
     end
@@ -149,7 +133,6 @@ module GdsApi
     # create_response: optional block to instantiate a custom response object
     #                  from the Net::HTTPResponse
     def do_json_request(method, url, params = nil, additional_headers = {}, &create_response)
-
       begin
         response = do_request_with_cache(method, url, (params.to_json if params), additional_headers)
       rescue RestClient::Exception => e
@@ -173,7 +156,7 @@ module GdsApi
       if @options[:bearer_token]
         headers = method_params[:headers] || {}
         method_params.merge(headers: headers.merge(
-          {"Authorization" => "Bearer #{@options[:bearer_token]}"}
+          "Authorization" => "Bearer #{@options[:bearer_token]}"
         ))
       elsif @options[:basic_auth]
         method_params.merge(
@@ -250,7 +233,7 @@ module GdsApi
     end
 
     def do_request(method, url, params = nil, additional_headers = {})
-      loggable = {request_uri: url, start_time: Time.now.to_f}
+      loggable = { request_uri: url, start_time: Time.now.to_f }
       start_logging = loggable.merge(action: 'start')
       logger.debug start_logging.to_json
 
@@ -284,6 +267,10 @@ module GdsApi
       logger.error loggable.merge(status: 'timeout', error_message: e.message, error_class: e.class.name, end_time: Time.now.to_f).to_json
       raise GdsApi::TimedOutException.new
 
+    rescue URI::InvalidURIError => e
+      logger.error loggable.merge(status: 'invalid_uri', error_message: e.message, error_class: e.class.name, end_time: Time.now.to_f).to_json
+      raise GdsApi::InvalidUrl
+
     rescue RestClient::Exception => e
       # Log the error here, since we have access to loggable, but raise the
       # exception up to the calling method to deal with

data/lib/gds_api/licence_application.rb

@@ -2,7 +2,7 @@ require_relative "base"
 
 class GdsApi::LicenceApplication < GdsApi::Base
   def all_licences
-    get_json!("#{@endpoint}/api/licences")
+    get_json("#{@endpoint}/api/licences")
   end
 
   def details_for_licence(id, snac_code = nil)
@@ -10,7 +10,7 @@ class GdsApi::LicenceApplication < GdsApi::Base
     get_json(build_licence_url(id, snac_code))
   end
 
-  private
+private
 
   def build_licence_url(id, snac_code)
     if snac_code

data/lib/gds_api/list_response.rb

@@ -3,14 +3,12 @@ require "gds_api/response"
 require "link_header"
 
 module GdsApi
-
   # Response class for lists of multiple items.
   #
   # This expects responses to be in a common format, with the list of results
   # contained under the `results` key. The response may also have previous and
   # subsequent pages, indicated by entries in the response's `Link` header.
   class ListResponse < Response
-
     # The ListResponse is instantiated with a reference back to the API client,
     # so it can make requests for the subsequent pages
     def initialize(response, api_client, options = {})
@@ -39,10 +37,8 @@ module GdsApi
       # allow the data to change once it's already been loaded, so long as we
       # retain a reference to any one page in the sequence
       @next_page ||= if has_next_page?
-        @api_client.get_list! page_link("next").href
-      else
-        nil
-      end
+                       @api_client.get_list page_link("next").href
+                     end
     end
 
     def has_previous_page?
@@ -51,10 +47,10 @@ module GdsApi
 
     def previous_page
       # See the note in `next_page` for why this is memoised
-      @previous_page ||= if has_previous_page?
-        @api_client.get_list! page_link("previous").href
-      else
-        nil
+      @previous_page ||= begin
+        if has_previous_page?
+          @api_client.get_list(page_link("previous").href)
+        end
       end
     end
 
@@ -86,6 +82,7 @@ module GdsApi
     end
 
   private
+
     def link_header
       @link_header ||= LinkHeader.parse @http_response.headers[:link]
     end

data/lib/gds_api/local_links_manager.rb

@@ -1,7 +1,7 @@
 require_relative 'base'
 
 class GdsApi::LocalLinksManager < GdsApi::Base
-  def local_link(authority_slug, lgsl, lgil=nil)
+  def local_link(authority_slug, lgsl, lgil = nil)
     url = "#{endpoint}/api/link?authority_slug=#{authority_slug}&lgsl=#{lgsl}"
     url += "&lgil=#{lgil}" if lgil
     get_json(url)

data/lib/gds_api/mapit.rb

@@ -2,7 +2,6 @@ require_relative 'base'
 require_relative 'exceptions'
 
 class GdsApi::Mapit < GdsApi::Base
-
   def location_for_postcode(postcode)
     response = get_json("#{base_url}/postcode/#{CGI.escape postcode}.json")
     Location.new(response) unless response.nil?
@@ -32,7 +31,7 @@ class GdsApi::Mapit < GdsApi::Base
     end
 
     def areas
-      @response['areas'].map {|i, area| OpenStruct.new(area) }
+      @response['areas'].map { |_i, area| OpenStruct.new(area) }
     end
 
     def postcode
@@ -40,9 +39,9 @@ class GdsApi::Mapit < GdsApi::Base
     end
   end
 
-  private
-    def base_url
-      endpoint
-    end
+private
 
+  def base_url
+    endpoint
+  end
 end

data/lib/gds_api/middleware/govuk_header_sniffer.rb

@@ -12,7 +12,7 @@ module GdsApi
       @app.call(env)
     end
 
-    private
+  private
 
     def readable_name
       @header_name.sub(/^HTTP_/, "").downcase.to_sym

data/lib/gds_api/need_api.rb

@@ -1,11 +1,10 @@
 require_relative 'base'
 
 class GdsApi::NeedApi < GdsApi::Base
-
   def needs(options = {})
     query = query_string(options)
 
-    get_list!("#{endpoint}/needs#{query}")
+    get_list("#{endpoint}/needs#{query}")
   end
 
   def content_id(need_id)
@@ -16,7 +15,7 @@ class GdsApi::NeedApi < GdsApi::Base
     ids_string = ids.flatten.map(&:to_i).sort.join(',')
     query = query_string(ids: ids_string)
 
-    get_list!("#{endpoint}/needs#{query}")
+    get_list("#{endpoint}/needs#{query}")
   end
 
   def need(need_id)
@@ -24,16 +23,16 @@ class GdsApi::NeedApi < GdsApi::Base
   end
 
   def create_need(need)
-    post_json!("#{endpoint}/needs", need)
+    post_json("#{endpoint}/needs", need)
   end
 
   def update_need(need_id, need_update)
     # `need_update` can be a hash of updated fields or a complete need
-    put_json!("#{endpoint}/needs/#{CGI.escape(need_id.to_s)}", need_update)
+    put_json("#{endpoint}/needs/#{CGI.escape(need_id.to_s)}", need_update)
   end
 
   def organisations
-    get_json!("#{endpoint}/organisations")["organisations"]
+    get_json("#{endpoint}/organisations")["organisations"]
   end
 
   def close(need_id, duplicate_of)
@@ -41,7 +40,7 @@ class GdsApi::NeedApi < GdsApi::Base
     # a need as a duplicate: { "duplicate_of" => 100001,
     #                          "author" => { ... }
     #                        }
-    put_json!("#{endpoint}/needs/#{CGI.escape(need_id.to_s)}/closed", duplicate_of)
+    put_json("#{endpoint}/needs/#{CGI.escape(need_id.to_s)}/closed", duplicate_of)
   end
 
   def reopen(need_id, author)
@@ -51,6 +50,6 @@ class GdsApi::NeedApi < GdsApi::Base
   end
 
   def create_note(note)
-    post_json!("#{endpoint}/notes", note)
+    post_json("#{endpoint}/notes", note)
   end
 end

data/lib/gds_api/null_cache.rb

@@ -1,13 +1,13 @@
 module GdsApi
   class NullCache
-    def [](k)
+    def [](_k)
       nil
     end
 
     def []=(k, v)
     end
 
-    def store(k, v, expiry_time=nil)
+    def store(k, v, expiry_time = nil)
     end
   end
 end

data/lib/gds_api/organisations.rb

@@ -1,9 +1,8 @@
 require_relative 'base'
 
 class GdsApi::Organisations < GdsApi::Base
-
   def organisations
-    get_list! "#{base_url}/organisations"
+    get_list "#{base_url}/organisations"
   end
 
   def organisation(organisation_slug)
@@ -11,6 +10,7 @@ class GdsApi::Organisations < GdsApi::Base
   end
 
 private
+
   def base_url
     "#{endpoint}/api"
   end

data/lib/gds_api/panopticon.rb

@@ -3,7 +3,6 @@ require_relative 'panopticon/registerer'
 require_relative 'exceptions'
 
 class GdsApi::Panopticon < GdsApi::Base
-
   include GdsApi::ExceptionHandling
 
   def all
@@ -12,8 +11,8 @@ class GdsApi::Panopticon < GdsApi::Base
     to_ostruct json
   end
 
-  def artefact_for_slug(slug, opts = {})
-    return nil if slug.nil? or slug == ''
+  def artefact_for_slug(slug, _opts = {})
+    return nil if slug.nil? || slug == ''
     get_json(url_for_slug(slug))
   end
 
@@ -24,7 +23,7 @@ class GdsApi::Panopticon < GdsApi::Base
   end
 
   def create_artefact!(artefact)
-    post_json!(base_url + ".json", artefact)
+    post_json(base_url + ".json", artefact)
   end
 
   def put_artefact(id_or_slug, artefact)
@@ -34,7 +33,7 @@ class GdsApi::Panopticon < GdsApi::Base
   end
 
   def put_artefact!(id_or_slug, artefact)
-    put_json!("#{base_url}/#{id_or_slug}.json", artefact)
+    put_json("#{base_url}/#{id_or_slug}.json", artefact)
   end
 
   def update_artefact(id_or_slug, artefact)
@@ -46,35 +45,36 @@ class GdsApi::Panopticon < GdsApi::Base
   end
 
   def delete_artefact!(id_or_slug)
-    delete_json!("#{base_url}/#{id_or_slug}.json")
+    delete_json("#{base_url}/#{id_or_slug}.json")
   end
 
   def create_tag(attributes)
-    post_json!("#{endpoint}/tags.json", attributes)
+    post_json("#{endpoint}/tags.json", attributes)
   end
 
   def put_tag(tag_type, tag_id, attributes)
-    put_json!(
+    put_json(
       tag_url(tag_type, tag_id),
       attributes
     )
   end
 
   def publish_tag(tag_type, tag_id)
-    post_json!(
+    post_json(
       tag_url(tag_type, tag_id, '/publish'),
       # we don't need to send any more data along with the publish request,
       # but a body is still required, so sending an empty JSON hash instead
-      { }
+      {}
     )
   end
 
 private
+
   def base_url
     "#{endpoint}/artefacts"
   end
 
-  def tag_url(tag_type, tag_id, action='')
+  def tag_url(tag_type, tag_id, action = '')
     "#{endpoint}/tags/#{tag_type}/#{tag_id}#{action}.json"
   end
 end