postman_paf 0.3.0

data/lib/postman_paf/exceptions/rule_6_exceptions.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module PostmanPAF
+  module Exceptions
+    module WhichException
+      RULE6_PREMISE_ELEMENTS = %w[buildingName subBuildingName].freeze
+
+      # Checks if the whole buildingName String contains an Exception I,
+      #   Exception II or Exception III. Then checks if last part of the
+      #   buildingName String (AKA numeric part) contains an exception.
+      #   Finally checks if the whole subBuildingName String contains an
+      #   Exception I, Exception II or Exception III.
+      # @param paf_address [Hash] to be converted.
+      # @return [Symbol] the Rule 6 conversion exception(s) to apply to
+      #   the address based on criteria met.
+      def self.exception_to_apply_rule6(paf_address:)
+        RULE6_PREMISE_ELEMENTS.each_with_object([]) do |premise_element, exceptions|
+          exception = if contains_digit_as_first_and_last?(paf_address[premise_element])
+                        :exception_i
+                      elsif contains_digit_as_first_and_penultimate_and_alpha_as_last?(paf_address[premise_element])
+                        :exception_ii
+                      elsif contains_one_alpha_character?(paf_address[premise_element])
+                        :exception_iii
+                      elsif premise_element == BUILDING_NAME
+                        # Checks buildingName ONLY for numeric part exception - no numeric part
+                        #   exceptions have been found for subBuildingName in test data.
+                        building_name_parts = paf_address[BUILDING_NAME].split(' ')
+                        if building_name_parts.size > 1
+                          last_part = building_name_parts.last
+                          if last_part.match?(/\d/)
+                            PostmanPAF::Exceptions::WhichException.last_part_exception_to_apply(paf_address: paf_address, last_part: last_part)
+                          else
+                            :no_exception
+                          end
+                        else
+                          :no_exception
+                        end
+                      else
+                        :no_exception
+                      end
+
+          premise_element_exception = "#{SimpleSymbolize.snakeize(premise_element)}_#{exception}".to_sym
+          exceptions << premise_element_exception
+        end
+      end
+    end
+  end
+end

data/lib/postman_paf/exceptions/which_exception.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module PostmanPAF
+  module Exceptions
+    module WhichException
+      # Exception I.
+      # @param address_data [String] buildingName or subBuildingName data.
+      # @return [Boolean] if first and last characters are numeric.
+      # @example
+      #   contains_digit_as_first_and_last?("1") #=> true
+      #   contains_digit_as_first_and_last?("1-2") #=> true
+      #   contains_digit_as_first_and_last?("1/2") #=> true
+      #   contains_digit_as_first_and_last?("1 Example House 2") #=> true
+      #   contains_digit_as_first_and_last?("1 Example House") #=> false
+      def self.contains_digit_as_first_and_last?(address_data)
+        address_data.match?(/^\d(.*\d)?$/)
+      end
+
+      # Exception II.
+      # @param address_data [String] buildingName or subBuildingName data.
+      # @return [Boolean] if first and penultimate characters are numeric and
+      #   last character is alphabetic. Case insensitive.
+      # @example
+      #   contains_digit_as_first_and_penultimate_and_alpha_as_last?("1A") #=> true
+      #   contains_digit_as_first_and_penultimate_and_alpha_as_last?("12A") #=> true
+      #   contains_digit_as_first_and_penultimate_and_alpha_as_last?("1 Example 2A") #=> true
+      #   contains_digit_as_first_and_penultimate_and_alpha_as_last?("1") #=> false
+      #   contains_digit_as_first_and_penultimate_and_alpha_as_last?("15 A2") #=> false
+      def self.contains_digit_as_first_and_penultimate_and_alpha_as_last?(address_data)
+        return false unless address_data.length >= 2
+
+        first, *middle, last = address_data.chars
+
+        first.match?(/[[:digit:]]/) &&
+          (middle.empty? || middle.last.match?(/[[:digit:]]/)) &&
+          last.match?(/[[:alpha:]]/)
+      end
+
+      # Exception III.
+      # @param address_data [String] buildingName or subBuildingName data.
+      # @return [Boolean] if one alphabetic character only. Case insensitive.
+      # @example
+      #   contains_one_alpha_character?("A") #=> true
+      #   contains_one_alpha_character?("b") #=> true
+      #   contains_one_alpha_character?("Z") #=> true
+      #   contains_one_alpha_character?("1") #=> false
+      def self.contains_one_alpha_character?(address_data)
+        return false unless address_data.length.eql? 1
+
+        address_data.match?(/^[a-zA-Z]$/)
+      end
+
+      # Exception to Rule.
+      # @param address_data [String] buildingName.
+      # @return [Boolean] if last part (i.e. numeric part) contains a number
+      #   between 0 and 9999.
+      # @example
+      #   contains_digit_between_0_and_9999?("Example 0") #=> true
+      #   contains_digit_between_0_and_9999?("Example 14") #=> true
+      #   contains_digit_between_0_and_9999?("Example 9999") #=> true
+      #   contains_digit_between_0_and_9999?("Example 10000") #=> false
+      def self.contains_digit_between_0_and_9999?(address_data)
+        address_data.match?(/ \d{1,4}$/)
+      end
+
+      # Exception IV.
+      # @param address_data [String] buildingName.
+      # @return [Boolean] if last part (i.e. numeric range or a numeric alpha
+      #   suffix) is prefixed by an addressing keyword. Case insensitive.
+      # @example
+      #   contains_address_keyword?("UNIT 1") #=> true
+      #   contains_address_keyword?("BLOCKS 1-2") #=> true
+      #   contains_address_keyword?("FLAT 12A") #=> true
+      #   contains_address_keyword?("shops 2-4") #=> true
+      #   contains_address_keyword?("STALLS") #=> false
+      def self.contains_address_keyword?(address_data)
+        last_part = address_data.split(' ').last
+
+        ['BACK OF', 'BLOCK', 'BLOCKS', 'BUILDING', 'FLAT', 'MAISONETTE', 'MAISONETTES', 'REAR OF', 'SHOP', 'SHOPS', 'STALL',
+         'STALLS', 'SUITE', 'SUITES', 'UNIT', 'UNITS'].each do |keyword|
+          regex = "(^|\\s)#{keyword} #{last_part.upcase}$"
+          return true if address_data.upcase.match?(regex)
+        end
+        false
+      end
+
+      # Exception V.
+      # @param address_data [String] buildingName.
+      # @return [Boolean] if penultimate part (i.e. word in a buildingName) is
+      #   followed by a whitespace and completed by numerics with decimals or
+      #   forward slashes.
+      # @example
+      #   contains_digits_with_decimals_or_forward_slashes?("Example 1.2") #=> true
+      #   contains_digits_with_decimals_or_forward_slashes?("Example 85/1") #=> true
+      #   contains_digits_with_decimals_or_forward_slashes?("Example 7:8") #=> false
+      def self.contains_digits_with_decimals_or_forward_slashes?(address_data)
+        last_part = address_data.split(' ').last
+
+        last_part.match?(%r{^\d+[.|/]\d+$})
+      end
+    end
+  end
+end

data/lib/postman_paf/printable_address.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module PostmanPAF
+  # Getter and setter class for variables of the converted address.
+  # @attr line1 [String] converted.
+  # @attr line2 [String] converted.
+  # @attr line3 [String] converted.
+  # @attr line4 [String] converted.
+  # @attr line5 [String] the postTown of an address. Not converted.
+  # @attr country [String] not converted.
+  # @attr postcode [String] not converted.
+  # @attr language [String] not converted.
+  # @attr dps [String] the delivery point suffix, a unique 2-digit
+  #   code for each delivery point in a postcode. Not converted.
+  class PrintableAddress
+    attr_accessor :line1, :line2, :line3, :line4, :line5, :country, :postcode, :language, :dps
+
+    # Converts PrintableAddress object to JSON Hash representation
+    #   without ActiveSupport.
+    # @return [Hash] converted address data as JSON Hash.
+    def as_json
+      {
+        'line1' => @line1,
+        'line2' => @line2,
+        'line3' => @line3,
+        'line4' => @line4,
+        'line5' => @line5,
+        'postcode' => @postcode,
+        'country' => @country,
+        'language' => @language,
+        'dps' => @dps
+      }
+    end
+  end
+end

data/lib/postman_paf/rules/address_builder.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module PostmanPAF
+  module Rules
+    module BuildAddress
+      # Builds PrintableAddress object and returns attributes as JSON.
+      # @param paf_address [Hash] to be converted.
+      # @param lines [Array<String>] the converted lines of address data.
+      #   Lines with an Integer value are type converted to a String.
+      #   Lines with a value of nil are removed before converted address
+      #   is returned.
+      def self.build_printable_address(paf_address:, lines:)
+        printable_address = PrintableAddress.new
+
+        lines.each_with_index do |line, index|
+          line_number = index + 1
+          line = line.to_s if line.is_a?(Integer)
+          printable_address.send("line#{line_number}=", line) unless line_number.eql?(6) || line_number.eql?(7)
+        end
+
+        printable_address.postcode = paf_address[POSTCODE].slice(0..7)
+        printable_address.country = paf_address[COUNTRY]
+        printable_address.language = paf_address[LANGUAGE]
+        printable_address.dps = paf_address[DPS]
+
+        printable_address.as_json.compact
+      end
+    end
+  end
+end

data/lib/postman_paf/rules/building_number.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module PostmanPAF
+  module Rules
+    module ApplyRule
+      # Places buildingNumber in converted printable format address depending
+      #   on thoroughfare and locality elements present in the PAF address.
+      # @param data [Array<String>] the converted lines of address data.
+      # @param paf_address [Hash] to be converted.
+      # @param number [String] the building number to be placed in the
+      #   converted address.
+      # @return data [Array<String>] the updated converted lines of
+      #   address data with the building number added.
+      def self.add_building_number(data:, paf_address:, number:)
+        if paf_address[DEPENDENT_THOROUGHFARE_NAME]
+          data << "#{number} #{paf_address[DEPENDENT_THOROUGHFARE_NAME]}"
+          data << paf_address[THOROUGHFARE_NAME]
+          data << paf_address[DOUBLE_DEPENDENT_LOCALITY]
+          data << paf_address[DEPENDENT_LOCALITY]
+        elsif paf_address[THOROUGHFARE_NAME]
+          data << "#{number} #{paf_address[THOROUGHFARE_NAME]}"
+          data << paf_address[DOUBLE_DEPENDENT_LOCALITY]
+          data << paf_address[DEPENDENT_LOCALITY]
+        elsif paf_address[DOUBLE_DEPENDENT_LOCALITY]
+          data << "#{number} #{paf_address[DOUBLE_DEPENDENT_LOCALITY]}"
+          data << paf_address[DEPENDENT_LOCALITY]
+        elsif paf_address[DEPENDENT_LOCALITY]
+          data << "#{number} #{paf_address[DEPENDENT_LOCALITY]}"
+        else
+          data << number
+        end
+      end
+    end
+  end
+end

data/lib/postman_paf/rules/rule_1.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module PostmanPAF
+  module Rules
+    module ApplyRule
+      # Applies conversion Rule 1 to the PAF address.
+      #   Rule 1 conversion criteria: organisationName.
+      #   Will also apply as a default if organisationName,
+      #   subBuildingName, buildingName + buildingNumber NOT
+      #   present. Exceptions are not applicable.
+      # @param paf_address [Hash] to be converted.
+      # @return data [Array<String>] the converted lines of address data.
+      def self.apply_rule1(paf_address:)
+        data = []
+
+        data << paf_address[ORGANISATION_NAME]
+        data << paf_address[DEPARTMENT_NAME]
+        data << "PO BOX #{paf_address[PO_BOX_NUMBER]}" if paf_address[PO_BOX_NUMBER]
+
+        data << paf_address[DEPENDENT_THOROUGHFARE_NAME]
+        data << paf_address[THOROUGHFARE_NAME]
+        data << paf_address[DOUBLE_DEPENDENT_LOCALITY]
+        data << paf_address[DEPENDENT_LOCALITY]
+      end
+    end
+  end
+end

data/lib/postman_paf/rules/rule_2.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module PostmanPAF
+  module Rules
+    module ApplyRule
+      # Applies conversion Rule 2 to the PAF address.
+      #   Rule 2 conversion criteria: buildingNumber OR
+      #   organisationName + buildingNumber. Exceptions
+      #   are not applicable.
+      # @param paf_address [Hash] to be converted.
+      # @return data [Array<String>] the converted lines of address data.
+      def self.apply_rule2(paf_address:)
+        data = []
+
+        data << paf_address[ORGANISATION_NAME]
+        data << paf_address[DEPARTMENT_NAME]
+        data << "PO BOX #{paf_address[PO_BOX_NUMBER]}" if paf_address[PO_BOX_NUMBER]
+
+        PostmanPAF::Rules::ApplyRule.add_building_number(data: data, paf_address: paf_address, number: paf_address[BUILDING_NUMBER])
+      end
+    end
+  end
+end

data/lib/postman_paf/rules/rule_3.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module PostmanPAF
+  module Rules
+    module ApplyRule
+      # Applies conversion Rule 3 to the PAF address. Rule 3 conversion
+      #   criteria: buildingName OR organisationName + buildingName.
+      #   Exceptions can apply to buildingName.
+      # @param paf_address [Hash] to be converted.
+      # @param exception [Symbol] the exception to be applied during
+      #   conversion.
+      # @return data [Array<String>] the converted lines of address data.
+      def self.apply_rule3(paf_address:, exception:)
+        data = []
+
+        data << paf_address[ORGANISATION_NAME]
+        data << paf_address[DEPARTMENT_NAME]
+        data << "PO BOX #{paf_address[PO_BOX_NUMBER]}" if paf_address[PO_BOX_NUMBER]
+
+        case exception
+        when :exception_i, :exception_ii, :exception_iii
+          if paf_address[DEPENDENT_THOROUGHFARE_NAME]
+            data << "#{paf_address[BUILDING_NAME]} #{paf_address[DEPENDENT_THOROUGHFARE_NAME]}"
+            data << paf_address[THOROUGHFARE_NAME]
+          else
+            data << "#{paf_address[BUILDING_NAME]} #{paf_address[THOROUGHFARE_NAME]}"
+          end
+        when :exception_i_numeric_part, :exception_ii_numeric_part
+          *name, number = paf_address[BUILDING_NAME].split(' ')
+          data << name.join(' ')
+          PostmanPAF::Rules::ApplyRule.add_building_number(data: data, paf_address: paf_address, number: number)
+        else
+          # Applies if :exception_to_rule, :exception_iv, :exception_v or :no_exception i.e. buildingName is not split
+          data << paf_address[BUILDING_NAME]
+          data << paf_address[DEPENDENT_THOROUGHFARE_NAME]
+          data << paf_address[THOROUGHFARE_NAME]
+        end
+
+        data << paf_address[DOUBLE_DEPENDENT_LOCALITY] unless data.include?(paf_address[DOUBLE_DEPENDENT_LOCALITY])
+        data << paf_address[DEPENDENT_LOCALITY] unless data.include?(paf_address[DEPENDENT_LOCALITY])
+        data
+      end
+    end
+  end
+end

data/lib/postman_paf/rules/rule_4.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module PostmanPAF
+  module Rules
+    module ApplyRule
+      # Applies conversion Rule 4 to the PAF address.
+      #   Rule 4 conversion criteria: buildingName + buildingNumber OR
+      #   organisationName + buildingName + buildingNumber. Exceptions
+      #   are not applicable.
+      # @param paf_address [Hash] to be converted.
+      # @return data [Array<String>] the converted lines of address data.
+      def self.apply_rule4(paf_address:)
+        data = []
+
+        data << paf_address[ORGANISATION_NAME]
+        data << paf_address[DEPARTMENT_NAME]
+        data << "PO BOX #{paf_address[PO_BOX_NUMBER]}" if paf_address[PO_BOX_NUMBER]
+
+        data << paf_address[BUILDING_NAME]
+        PostmanPAF::Rules::ApplyRule.add_building_number(data: data, paf_address: paf_address, number: paf_address[BUILDING_NUMBER])
+      end
+    end
+  end
+end

data/lib/postman_paf/rules/rule_5.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module PostmanPAF
+  module Rules
+    module ApplyRule
+      # Applies conversion Rule 5 to the PAF address. Rule 5 conversion
+      #   criteria: subBuildingName + buildingNumber OR organisationName
+      #   + subBuildingName + buildingNumber. Exceptions can apply to
+      #   subBuildingName ONLY.
+      # @param paf_address [Hash] to be converted.
+      # @param exception [Symbol] the exception to be applied during
+      #   conversion.
+      # @return data [Array<String>] the converted lines of address data.
+      def self.apply_rule5(paf_address:, exception:)
+        data = []
+
+        data << paf_address[ORGANISATION_NAME]
+        data << paf_address[DEPARTMENT_NAME]
+        data << "PO BOX #{paf_address[PO_BOX_NUMBER]}" if paf_address[PO_BOX_NUMBER]
+
+        case exception
+        when :exception_i, :exception_ii
+          number = "#{paf_address[SUB_BUILDING_NAME]} #{paf_address[BUILDING_NUMBER]}"
+          PostmanPAF::Rules::ApplyRule.add_building_number(data: data, paf_address: paf_address, number: number)
+        when :exception_iii
+          number = "#{paf_address[BUILDING_NUMBER]}#{paf_address[SUB_BUILDING_NAME]}"
+          PostmanPAF::Rules::ApplyRule.add_building_number(data: data, paf_address: paf_address, number: number)
+        else
+          data << paf_address[SUB_BUILDING_NAME]
+          PostmanPAF::Rules::ApplyRule.add_building_number(data: data, paf_address: paf_address, number: paf_address[BUILDING_NUMBER])
+        end
+      end
+    end
+  end
+end

data/lib/postman_paf/rules/rule_6.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module PostmanPAF
+  module Rules
+    module ApplyRule
+      SUB_BUILDING_NAME_EXCEPTIONS = %i[sub_building_name_exception_i sub_building_name_exception_ii sub_building_name_exception_iii].freeze
+
+      # Applies conversion Rule 6 to the PAF address. Rule 6 conversion
+      #   criteria: subBuildingName + buildingName OR organisationName
+      #   + subBuildingName + buildingName. Exceptions can apply to
+      #   subBuildingName AND/OR buildingName.
+      # @param paf_address [Hash] to be converted.
+      # @param exceptions [Array<Symbol>] the exceptions to be applied
+      #   during conversion.
+      # @return data [Array<String>] the converted lines of address data.
+      def self.apply_rule6(paf_address:, exceptions:)
+        building_name_exception = exceptions.first
+        sub_building_name_exception = exceptions.last
+
+        data = []
+
+        data << paf_address[ORGANISATION_NAME]
+        data << paf_address[DEPARTMENT_NAME]
+        data << "PO BOX #{paf_address[PO_BOX_NUMBER]}" if paf_address[PO_BOX_NUMBER]
+
+        case building_name_exception
+        when :building_name_exception_i, :building_name_exception_ii, :building_name_exception_iii
+          # Applies regardless of sub_building_name_exception.
+          if paf_address[DEPENDENT_THOROUGHFARE_NAME]
+            data << paf_address[SUB_BUILDING_NAME]
+            data << "#{paf_address[BUILDING_NAME]} #{paf_address[DEPENDENT_THOROUGHFARE_NAME]}"
+            data << paf_address[THOROUGHFARE_NAME]
+          else
+            data << paf_address[SUB_BUILDING_NAME]
+            data << "#{paf_address[BUILDING_NAME]} #{paf_address[THOROUGHFARE_NAME]}"
+          end
+        when :building_name_exception_i_numeric_part, :building_name_exception_ii_numeric_part
+          if SUB_BUILDING_NAME_EXCEPTIONS.include?(sub_building_name_exception)
+            *name, number = paf_address[BUILDING_NAME].split(' ')
+            data << "#{paf_address[SUB_BUILDING_NAME]} #{name.join(" ")}"
+            PostmanPAF::Rules::ApplyRule.add_building_number(data: data, paf_address: paf_address, number: number)
+          else
+            *name, number = paf_address[BUILDING_NAME].split(' ')
+            data << paf_address[SUB_BUILDING_NAME]
+            data << name.join(' ')
+            PostmanPAF::Rules::ApplyRule.add_building_number(data: data, paf_address: paf_address, number: number)
+          end
+        else
+          # Applies if :building_name_exception_to_rule, :building_name_exception_iv, :building_name_exception_v or :building_name_no_exception
+          # i.e. buildingName is not split
+          if SUB_BUILDING_NAME_EXCEPTIONS.include?(sub_building_name_exception)
+            data << "#{paf_address[SUB_BUILDING_NAME]} #{paf_address[BUILDING_NAME]}"
+            data << paf_address[DEPENDENT_THOROUGHFARE_NAME]
+            data << paf_address[THOROUGHFARE_NAME]
+          else
+            data << paf_address[SUB_BUILDING_NAME]
+            data << paf_address[BUILDING_NAME]
+            data << paf_address[DEPENDENT_THOROUGHFARE_NAME]
+            data << paf_address[THOROUGHFARE_NAME]
+          end
+        end
+
+        data << paf_address[DOUBLE_DEPENDENT_LOCALITY] unless data.include?(paf_address[DOUBLE_DEPENDENT_LOCALITY])
+        data << paf_address[DEPENDENT_LOCALITY] unless data.include?(paf_address[DEPENDENT_LOCALITY])
+        data
+      end
+    end
+  end
+end

data/lib/postman_paf/rules/rule_7.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module PostmanPAF
+  module Rules
+    module ApplyRule
+      # Applies conversion Rule 7 to the PAF address. Rule 7 conversion
+      #   criteria: subBuildingName + buildingName + buildingNumber OR
+      #   organisationName + subBuildingName + buildingName +
+      #   buildingNumber. Exceptions can apply to subBuildingName ONLY.
+      # @param paf_address [Hash] to be converted.
+      # @param exception [Symbol] the exception to be applied during
+      #   conversion.
+      # @return data [Array<String>] the converted lines of address data.
+      def self.apply_rule7(paf_address:, exception:)
+        data = []
+
+        data << paf_address[ORGANISATION_NAME]
+        data << paf_address[DEPARTMENT_NAME]
+        data << "PO BOX #{paf_address[PO_BOX_NUMBER]}" if paf_address[PO_BOX_NUMBER]
+
+        case exception
+        when :exception_i, :exception_ii, :exception_iii
+          data << "#{paf_address[SUB_BUILDING_NAME]} #{paf_address[BUILDING_NAME]}"
+        else
+          data << paf_address[SUB_BUILDING_NAME]
+          data << paf_address[BUILDING_NAME]
+        end
+
+        PostmanPAF::Rules::ApplyRule.add_building_number(data: data, paf_address: paf_address, number: paf_address[BUILDING_NUMBER])
+      end
+    end
+  end
+end

data/lib/postman_paf/rules/rules.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module PostmanPAF
+  module Rules
+    # PAF address elements:
+    ORGANISATION_NAME = 'organisationName'
+    DEPARTMENT_NAME = 'departmentName'
+    PO_BOX_NUMBER = 'poBoxNumber'
+    BUILDING_NUMBER = 'buildingNumber'
+    BUILDING_NAME = 'buildingName'
+    SUB_BUILDING_NAME = 'subBuildingName'
+    THOROUGHFARE_NAME = 'thoroughfareName'
+    DEPENDENT_THOROUGHFARE_NAME = 'dependentThoroughfareName'
+    DEPENDENT_LOCALITY = 'dependentLocality'
+    DOUBLE_DEPENDENT_LOCALITY = 'doubleDependentLocality'
+    POST_TOWN = 'postTown'
+    POSTCODE = 'postcode'
+    COUNTRY = 'country'
+    LANGUAGE = 'language'
+    DPS = 'dps'
+    # Only the presence of subBuildingName, buildingName and
+    #   buildingNumber determine which Rule applies.
+    ADDRESS_ELEMENTS_FOR_RULE = %w[subBuildingName buildingName buildingNumber].freeze
+
+    # Identifies address elements found in PAF address and returns
+    #   applicable rule.
+    # @param paf_address [Hash] to be converted.
+    # @return [Symbol] the conversion rule to apply to the address
+    #   based on address elements found.
+    def self.which_rule(paf_address:)
+      found_premise_elements = []
+
+      paf_address.each do |key, value|
+        # to_s is used to handle an Integer value in the PAF address.
+        found_premise_elements << key if ADDRESS_ELEMENTS_FOR_RULE.include?(key) && !value.to_s.empty?
+      end
+
+      PostmanPAF::Rules::WhichRule.rule_to_apply(premise_elements: found_premise_elements)
+    end
+
+    # Applies the applicable rule and exception (if applicable) to
+    #   create the converted printable address data. Rule 1
+    #   applies for a PAF address containing an organisationName,
+    #   but also applies when defaulting to Rule 1 for a PAF address
+    #   that does not contain: organisationName, subBuildingName,
+    #   buildingName or buildingNumber.
+    # @param rule [Symbol] the conversion rule to be applied to the
+    #   address.
+    # @param paf_address [Hash] to be converted.
+    # @param exception [Symbol] applied during conversion.
+    # @return [Array] converted address data.
+    def self.apply_rule(rule:, paf_address:, exception:)
+      case rule
+      when :rule2
+        PostmanPAF::Rules::ApplyRule.apply_rule2(paf_address: paf_address)
+      when :rule3
+        PostmanPAF::Rules::ApplyRule.apply_rule3(paf_address: paf_address, exception: exception)
+      when :rule4
+        PostmanPAF::Rules::ApplyRule.apply_rule4(paf_address: paf_address)
+      when :rule5
+        PostmanPAF::Rules::ApplyRule.apply_rule5(paf_address: paf_address, exception: exception)
+      when :rule6
+        PostmanPAF::Rules::ApplyRule.apply_rule6(paf_address: paf_address, exceptions: exception)
+      when :rule7
+        PostmanPAF::Rules::ApplyRule.apply_rule7(paf_address: paf_address, exception: exception)
+      else
+        PostmanPAF::Rules::ApplyRule.apply_rule1(paf_address: paf_address)
+      end
+    end
+  end
+end

data/lib/postman_paf/rules/which_rule.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module PostmanPAF
+  module Rules
+    module WhichRule
+      RULE_02 = %w[buildingNumber].freeze
+      RULE_03 = %w[buildingName].freeze
+      RULE_04 = %w[buildingName buildingNumber].freeze
+      RULE_05 = %w[buildingNumber subBuildingName].freeze
+      RULE_06 = %w[buildingName subBuildingName].freeze
+      RULE_07 = %w[buildingName buildingNumber subBuildingName].freeze
+
+      # Matches address elements found in PAF address to criteria for
+      #   applicable Royal Mail rule. Rule 1 is defaulted to if
+      #   subBuildingName, buildingName and buildingNumber are NOT
+      #   present.
+      # @param premise_elements [Array<String>] the premise elements
+      #   found in the PAF address.
+      # @return [Symbol] the applicable Royal Mail conversion rule.
+      def self.rule_to_apply(premise_elements:)
+        case premise_elements.sort
+        when RULE_02
+          :rule2
+        when RULE_03
+          :rule3
+        when RULE_04
+          :rule4
+        when RULE_05
+          :rule5
+        when RULE_06
+          :rule6
+        when RULE_07
+          :rule7
+        else
+          :rule1
+        end
+      end
+    end
+  end
+end