ideal_postcodes 2.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: ced7ca1b0bfedf6e6e3de16898062cc335927ed5
-  data.tar.gz: a59fe3d7b1cc4797842872997a7128ee1e2399e3
+SHA256:
+  metadata.gz: 631e1f7827c1ebd216ac8da69d07f41e99dfcb542ea8db79160f81fb4e27e2f7
+  data.tar.gz: 528c592ee660794a49eaca814817181d7bb46dc67a848dd3015d9ed64023af3a
 SHA512:
-  metadata.gz: 79892c818f0d4319a12ec35ef81aca5aee11d5478742989bfe0f87fc4f77e1567c4efbd08d254663984a5aee15ba4ee15a79fffe91c3e4d34f413951ec42ba04
-  data.tar.gz: 471e2ac36ad0eb8c662a641e11d5d7d23b5e77c0952901b18611ee01ae54d26717c86b198d63635d48451a5deca67e34a61379d31643f303404bfba84079795f
+  metadata.gz: f9f1c1c8405bad2e5f2593609a880f667f5b1b89643540e197aa79d348f1027abcfa7ca0de1c16d485861a6ab9d42471761068435b56be25584ed7cbcc269799
+  data.tar.gz: '078849bcd14507cab9dcc8263bcd823dd154d556da85065b8909b37ae5b504c51aa0d8a67b6413c487e82f5b37c4415abdab033ceb98465d450848f6a272ff8e'

data/.github/workflows/ci.yml

@@ -0,0 +1,22 @@
+name: CI
+on:
+  push:
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby: 
+          - '2.5'
+          - '2.6'
+          - '2.7'
+          - '3.0'
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - name: Run tests
+        run: bundle exec rake

data/lib/ideal_postcodes.rb

@@ -1,2 +1,2 @@
 # Allows to reference by ideal_postcodes
-require 'idealpostcodes'
+require 'idealpostcodes'

data/lib/idealpostcodes/address.rb

@@ -1,31 +1,31 @@
 module IdealPostcodes
-	module Address
-		class SearchResult
-			attr_reader :page, :limit, :addresses
-			def initialize response
-				@page = response[:result][:page]
-				@limit = response[:result][:limit]
-				@addresses = response[:result][:hits]
-			end
-		end
+  module Address
+    class SearchResult
+      attr_reader :page, :limit, :addresses
+      def initialize(response)
+        @page = response[:result][:page]
+        @limit = response[:result][:limit]
+        @addresses = response[:result][:hits]
+      end
+    end
 
-		def self.lookup udprn
-			begin
-				response = IdealPostcodes.request :get, "addresses/#{udprn}"
-				address = response[:result]
-			rescue IdealPostcodes::IdealPostcodesError => error
-				raise error unless error.response_code == 4044
-				address = nil
-			end
-			address
-		end
+    def self.lookup(udprn)
+      begin
+        response = IdealPostcodes.request :get, "addresses/#{udprn}"
+        address = response[:result]
+      rescue IdealPostcodes::IdealPostcodesError => error
+        raise error unless error.response_code == 4044
+        address = nil
+      end
+      address
+    end
 
-		def self.search search_term, options = {}
-			query = { query: search_term }
-			query[:limit] = options[:limit] unless options[:limit].nil?
-			query[:page] = options[:page] unless options[:page].nil?
-			response = IdealPostcodes.request :get, "addresses", query
-			SearchResult.new response
-		end
-	end
-end
+    def self.search(search_term, options = {})
+      query = { query: search_term }
+      query[:limit] = options[:limit] unless options[:limit].nil?
+      query[:page] = options[:page] unless options[:page].nil?
+      response = IdealPostcodes.request :get, 'addresses', query
+      SearchResult.new response
+    end
+  end
+end

data/lib/idealpostcodes/errors.rb

@@ -1,33 +1,38 @@
 module IdealPostcodes
-	class IdealPostcodesError < StandardError
-		attr_reader :message
-		attr_reader :http_code
-		attr_reader :http_body
-		attr_reader :response_code
+  class IdealPostcodesError < StandardError
+    attr_reader :message
+    attr_reader :http_code
+    attr_reader :http_body
+    attr_reader :response_code
 
-		def initialize(message = nil, http_code = nil, http_body = nil, response_code = nil)
-			@message = message
-			@http_code = http_code
-			@http_body = http_body
-			@response_code = response_code
-		end
+    def initialize(
+      message = nil,
+      http_code = nil,
+      http_body = nil,
+      response_code = nil
+    )
+      @message = message
+      @http_code = http_code
+      @http_body = http_body
+      @response_code = response_code
+    end
 
-		def to_s
-			status = @http_code.nil? ? "" : "#{@http_code} error."
-			ideal_code = @response_code.nil? ? "" : "(#{@response_code})"
-			"#{status} error. (#{ideal_code}) #{message}"
-		end
-	end
+    def to_s
+      status = @http_code.nil? ? '' : "#{@http_code} error."
+      ideal_code = @response_code.nil? ? '' : "(#{@response_code})"
+      "#{status} error. (#{ideal_code}) #{message}"
+    end
+  end
 
-	class AuthenticationError< IdealPostcodesError
-	end
+  class AuthenticationError < IdealPostcodesError
+  end
 
-	class TokenExhaustedError < IdealPostcodesError
-	end
+  class TokenExhaustedError < IdealPostcodesError
+  end
 
-	class LimitReachedError < IdealPostcodesError
-	end
+  class LimitReachedError < IdealPostcodesError
+  end
 
-	class ResourceNotFoundError < IdealPostcodesError
-	end
-end
+  class ResourceNotFoundError < IdealPostcodesError
+  end
+end

data/lib/idealpostcodes/key.rb

@@ -1,13 +1,14 @@
 module IdealPostcodes
-	module Key
-		def self.lookup api_key
-			response = IdealPostcodes.request :get, "keys/#{api_key}"
-			response[:result]
-		end
+  module Key
+    def self.lookup(api_key)
+      response = IdealPostcodes.request :get, "keys/#{api_key}"
+      response[:result]
+    end
 
-		def self.lookup_details api_key, secret
-			response = IdealPostcodes.request :get, "keys/#{api_key}", { user_token: secret }
-			response[:result]
-		end
-	end
-end
+    def self.lookup_details(api_key, secret)
+      response =
+        IdealPostcodes.request :get, "keys/#{api_key}", { user_token: secret }
+      response[:result]
+    end
+  end
+end

data/lib/idealpostcodes/postcode.rb

@@ -1,22 +1,23 @@
 module IdealPostcodes
-	module Postcode
-		def self.lookup postcode
-			begin
-				response = IdealPostcodes.request :get, "postcodes/#{postcode}"
-				addresses = response[:result]
-			rescue IdealPostcodes::ResourceNotFoundError => error
-				raise error unless error.response_code == 4040
-				addresses = []
-			end
-			addresses
-		end
+  module Postcode
+    def self.lookup(postcode)
+      begin
+        response = IdealPostcodes.request :get, "postcodes/#{postcode}"
+        addresses = response[:result]
+      rescue IdealPostcodes::ResourceNotFoundError => e
+        raise e unless e.response_code == 4040
 
-		def self.find_by_location geolocation
-			query = {lonlat: "#{geolocation[:longitude]},#{geolocation[:latitude]}"}
-			query[:limit] = geolocation[:limit] unless geolocation[:limit].nil?
-			query[:radius] = geolocation[:radius] unless geolocation[:radius].nil?
-			response = IdealPostcodes.request :get, 'postcodes', query
-			response[:result]
-		end
-	end
-end
+        addresses = []
+      end
+      addresses
+    end
+
+    def self.find_by_location(geolocation)
+      query = { lonlat: "#{geolocation[:longitude]},#{geolocation[:latitude]}" }
+      query[:limit] = geolocation[:limit] unless geolocation[:limit].nil?
+      query[:radius] = geolocation[:radius] unless geolocation[:radius].nil?
+      response = IdealPostcodes.request :get, 'postcodes', query
+      response[:result]
+    end
+  end
+end

data/lib/idealpostcodes/util.rb

@@ -1,29 +1,42 @@
+require 'uri'
+
 module IdealPostcodes
-	class Util
+  DEFAULT_PARSER = URI::Parser.new
 
-		def self.merge_params(hash)
-			result = []
-			hash.each do |key, value|
-				result << "#{CGI.escape(key.to_s)}=#{CGI.escape(value.to_s)}"
-			end
-			result.join('&')
-		end
+  class Util
+    def self.escape(str)
+      IdealPostcodes::DEFAULT_PARSER.escape(str)
+    end
 
-		def self.keys_to_sym(object)
-			case object
-			when Hash
-				temp = {}
-				object.each do |key, value|
-					key = (key.to_sym rescue key) || key
-          temp[key] = keys_to_sym(value)
-				end
-				temp
-			when Array
-				object.map { |elem| keys_to_sym(elem) }
-			else
-				object
-			end
-		end
+    def self.merge_params(hash)
+      result = []
+      hash.each do |key, value|
+        result << "#{escape(key.to_s)}=#{escape(value.to_s)}"
+      end
+      result.join('&')
+    end
 
-	end
-end
+    def self.keys_to_sym(object)
+      case object
+      when Hash
+        temp = {}
+        object.each do |key, value|
+          key =
+            (
+              begin
+                key.to_sym
+              rescue StandardError
+                key
+              end
+            ) || key
+          temp[key] = keys_to_sym(value)
+        end
+        temp
+      when Array
+        object.map { |elem| keys_to_sym(elem) }
+      else
+        object
+      end
+    end
+  end
+end

data/lib/idealpostcodes/version.rb

@@ -1,3 +1,3 @@
 module IdealPostcodes
-	VERSION = '2.0.0'
-end
+  VERSION = '2.0.1'
+end

data/lib/idealpostcodes.rb

@@ -14,99 +14,111 @@ require 'idealpostcodes/address'
 require 'idealpostcodes/postcode'
 
 module IdealPostcodes
-	@base_url = 'https://api.ideal-postcodes.co.uk'
-	@version = '1'
-
-	class << self
-		attr_accessor :api_key, :base_url, :version, :secret
-	end
-
-	def self.request(method, path, params = {})
-		unless @api_key
-			raise IdealPostcodes::AuthenticationError.new('No API Key provided. ' +
-				'Set your key with IdealPostcodes.api_key = #your_key')
-		end
-
-		url = URI.parse(resource_url(path))
-		params.merge! api_key: @api_key
-		url.query = Util.merge_params(params)
-		request_options = {
-			method: method.downcase.to_sym,
-			url: url.to_s
-		}
-
-		begin
-			response = generate_request(request_options)
-		rescue RestClient::ExceptionWithResponse => error
-			if rcode = error.http_code && rbody = error.http_body
-				handle_error(rcode, rbody)
-			else
-				handle_client_error(error)
-			end
-		rescue RestClient::Exception, Errno::ECONNREFUSED => error
-			handle_client_error(error)
-		end
-		parse response.body
-	end
-
-	def self.apply_secret(secret)
-		@secret = secret
-	end
-
-	def self.key_available
-		response = Key.lookup @api_key
-		response[:available]
-	end
-
-	def self.key_details
-		raise IdealPostcodes::AuthenticationError.new('No Secret Key provided. ' +
-				'Set your secret key with IdealPostcodes.apply_secret #your_key') if @secret.nil?
-		response = Key.lookup_details @api_key, @secret
-	end
-
-	private
-
-	def self.resource_url(path='')
-		URI.escape "#{@base_url}/v#{@version}/#{path}"
-	end
-
-	def self.generate_request(options)
-		RestClient::Request.execute(options)
-	end
-
-	def self.parse(response)
-		begin
-      Util.keys_to_sym JSON.parse(response)
-    rescue JSON::ParserError => e
-      raise handle_client_error(e)
+  @base_url = 'https://api.ideal-postcodes.co.uk'
+  @version = '1'
+
+  class << self
+    attr_accessor :api_key, :base_url, :version, :secret
+  end
+
+  def self.request(method, path, params = {})
+    unless @api_key
+      raise IdealPostcodes::AuthenticationError, 'No API Key provided. ' +
+                                                 'Set your key with IdealPostcodes.api_key = #your_key'
+    end
+
+    url = URI.parse(resource_url(path))
+    params.merge! api_key: @api_key
+    url.query = Util.merge_params(params)
+    request_options = { method: method.downcase.to_sym, url: url.to_s }
+
+    begin
+      response = generate_request(request_options)
+    rescue RestClient::ExceptionWithResponse => e
+      if rcode = e.http_code && rbody = e.http_body
+        handle_error(rcode, rbody)
+      else
+        handle_client_error(e)
+      end
+    rescue RestClient::Exception, Errno::ECONNREFUSED => e
+      handle_client_error(e)
+    end
+    parse response.body
+  end
+
+  def self.apply_secret(secret)
+    @secret = secret
+  end
+
+  def self.key_available
+    response = Key.lookup @api_key
+    response[:available]
+  end
+
+  def self.key_details
+    if @secret.nil?
+      raise IdealPostcodes::AuthenticationError, 'No Secret Key provided. ' +
+                                                 'Set your secret key with IdealPostcodes.apply_secret #your_key'
     end
-	end
+    response = Key.lookup_details @api_key, @secret
+  end
 
-	def self.handle_error(http_code, http_body)
+  def self.resource_url(path = '')
+    IdealPostcodes::Util.escape "#{@base_url}/v#{@version}/#{path}"
+  end
+
+  def self.generate_request(options)
+    RestClient::Request.execute(options)
+  end
+
+  def self.parse(response)
+    Util.keys_to_sym JSON.parse(response)
+  rescue JSON::ParserError => e
+    raise handle_client_error(e)
+  end
+
+  def self.handle_error(http_code, http_body)
     error = parse http_body
 
-		ideal_code, ideal_message = error[:code], error[:message]
-		
-		case ideal_code
-		when 4010
-			raise AuthenticationError.new ideal_message, http_code, http_body, ideal_code
-		when 4020
-			raise TokenExhaustedError.new ideal_message, http_code, http_body, ideal_code
-		when 4021
-			raise LimitReachedError.new ideal_message, http_code, http_body, ideal_code
-		when 4040
-			raise ResourceNotFoundError.new ideal_message, http_code, http_body, ideal_code
-		else
-			raise IdealPostcodesError.new ideal_message, http_code, http_body, ideal_code
-		end
-	end
-
-	def self.handle_client_error(error)
-		raise IdealPostcodesError.new("An unexpected error occured: #{error.message})")
-	end
-
-	def self.general_error(response_code, response_body)
-		IdealPostcodesError.new 'Invalid response object', response_code, response_body
-	end
-
-end
+    ideal_code = error[:code]
+    ideal_message = error[:message]
+
+    case ideal_code
+    when 4010
+      raise AuthenticationError.new ideal_message,
+                                    http_code,
+                                    http_body,
+                                    ideal_code
+    when 4020
+      raise TokenExhaustedError.new ideal_message,
+                                    http_code,
+                                    http_body,
+                                    ideal_code
+    when 4021
+      raise LimitReachedError.new ideal_message,
+                                  http_code,
+                                  http_body,
+                                  ideal_code
+    when 4040
+      raise ResourceNotFoundError.new ideal_message,
+                                      http_code,
+                                      http_body,
+                                      ideal_code
+    else
+      raise IdealPostcodesError.new ideal_message,
+                                    http_code,
+                                    http_body,
+                                    ideal_code
+    end
+  end
+
+  def self.handle_client_error(error)
+    raise IdealPostcodesError, "An unexpected error occured: #{error.message})"
+  end
+
+  def self.general_error(response_code, response_body)
+    IdealPostcodesError.new 'Invalid response object',
+                            response_code,
+                            response_body
+  end
+end

data/spec/addresses_spec.rb

@@ -1,68 +1,68 @@
 require 'spec_helper'
 
 describe IdealPostcodes::Address do
-	describe '.lookup' do
-		it 'returns an address for a valid UDPRN' do
-			address = IdealPostcodes::Address.lookup 0
-			expect(is_address(address)).to eq(true)
-		end
-		it 'returns nil for an invalid UDPRN' do
-			address = IdealPostcodes::Address.lookup -1
-			expect(address).to be_nil
-		end
-		it 'raises an exception if invalid key' do
-			IdealPostcodes.api_key = 'foo'
-			expect {
-				IdealPostcodes::Address.lookup 0
-			}.to raise_error(IdealPostcodes::AuthenticationError)
-		end
-		it 'raises an exception if no lookups remaining' do
-			expect {
-				IdealPostcodes::Address.lookup -2
-			}.to raise_error(IdealPostcodes::TokenExhaustedError)
-		end
-		it 'raises an exception if limit breached' do
-			expect {
-				IdealPostcodes::Address.lookup -3
-			}.to raise_error(IdealPostcodes::LimitReachedError)
-		end
-	end	
+  describe '.lookup' do
+    it 'returns an address for a valid UDPRN' do
+      address = IdealPostcodes::Address.lookup 0
+      expect(is_address(address)).to eq(true)
+    end
+    it 'returns nil for an invalid UDPRN' do
+      address = IdealPostcodes::Address.lookup -1
+      expect(address).to be_nil
+    end
+    it 'raises an exception if invalid key' do
+      IdealPostcodes.api_key = 'foo'
+      expect { IdealPostcodes::Address.lookup 0 }.to raise_error(
+        IdealPostcodes::AuthenticationError
+      )
+    end
+    it 'raises an exception if no lookups remaining' do
+      expect { IdealPostcodes::Address.lookup -2 }.to raise_error(
+        IdealPostcodes::TokenExhaustedError
+      )
+    end
+    it 'raises an exception if limit breached' do
+      expect { IdealPostcodes::Address.lookup -3 }.to raise_error(
+        IdealPostcodes::LimitReachedError
+      )
+    end
+  end
 
-	describe '.search' do
-		it 'returns results in a SearchResult object' do
-			results = IdealPostcodes::Address.search "ID1 1QD"
-			expect(results).to be_a(IdealPostcodes::Address::SearchResult)
-			expect(results.addresses.length).to be > 0
-			results.addresses.each do |address|
-				expect(is_address(address)).to eq(true)
-			end
-		end
-		it 'is sensitive to limit' do
-			limit = 1
-			results = IdealPostcodes::Address.search "High Street", limit: limit
-			expect(results.addresses.length).to equal(limit)
-			expect(results.limit).to equal(limit)
-		end
-		it 'is sensitive to page' do
-			page = 1
-			results = IdealPostcodes::Address.search "High Street", page: page
-			expect(results.page).to equal(page)
-		end
-		it 'raises an exception if invalid key' do
-			IdealPostcodes.api_key = 'foo'
-			expect {
-				results = IdealPostcodes::Address.search "ID1 1QD"
-			}.to raise_error(IdealPostcodes::AuthenticationError)
-		end
-		it 'raises an exception if no lookups remaining' do
-			expect {
-				results = IdealPostcodes::Address.search "ID1 CLIP"
-			}.to raise_error(IdealPostcodes::TokenExhaustedError)
-		end
-		it 'raises an exception if limit breached' do
-			expect {
-				results = IdealPostcodes::Address.search "ID1 CHOP"
-			}.to raise_error(IdealPostcodes::LimitReachedError)
-		end
-	end
+  describe '.search' do
+    it 'returns results in a SearchResult object' do
+      results = IdealPostcodes::Address.search 'ID1 1QD'
+      expect(results).to be_a(IdealPostcodes::Address::SearchResult)
+      expect(results.addresses.length).to be > 0
+      results.addresses.each do |address|
+        expect(is_address(address)).to eq(true)
+      end
+    end
+    it 'is sensitive to limit' do
+      limit = 1
+      results = IdealPostcodes::Address.search 'High Street', limit: limit
+      expect(results.addresses.length).to equal(limit)
+      expect(results.limit).to equal(limit)
+    end
+    it 'is sensitive to page' do
+      page = 1
+      results = IdealPostcodes::Address.search 'High Street', page: page
+      expect(results.page).to equal(page)
+    end
+    it 'raises an exception if invalid key' do
+      IdealPostcodes.api_key = 'foo'
+      expect {
+        results = IdealPostcodes::Address.search 'ID1 1QD'
+      }.to raise_error(IdealPostcodes::AuthenticationError)
+    end
+    it 'raises an exception if no lookups remaining' do
+      expect {
+        results = IdealPostcodes::Address.search 'ID1 CLIP'
+      }.to raise_error(IdealPostcodes::TokenExhaustedError)
+    end
+    it 'raises an exception if limit breached' do
+      expect {
+        results = IdealPostcodes::Address.search 'ID1 CHOP'
+      }.to raise_error(IdealPostcodes::LimitReachedError)
+    end
+  end
 end