atdis 0.3.13 → 0.4.0

data/lib/atdis/models/pagination.rb

@@ -1,67 +1,126 @@
+# frozen_string_literal: true
+
 module ATDIS
   module Models
     class Pagination < Model
-      set_field_mappings ({
-        previous: Fixnum,
-        next:     Fixnum,
-        current:  Fixnum,
-        per_page: Fixnum,
-        count:    Fixnum,
-        pages:    Fixnum
-      })
+      field_mappings(
+        previous: Integer,
+        next: Integer,
+        current: Integer,
+        per_page: Integer,
+        count: Integer,
+        pages: Integer
+      )
 
       validate :all_pagination_is_present, :previous_is_consistent,
-        :next_is_consistent, :current_is_consistent,
-        :count_is_consistent
+               :next_is_consistent, :current_is_consistent,
+               :count_is_consistent
 
       # If some of the pagination fields are present all of the required ones should be present
       def all_pagination_is_present
-        errors.add(:current, ErrorMessage["should be present if pagination is being used", "6.4"]) if current.nil?
-        errors.add(:per_page, ErrorMessage["should be present if pagination is being used", "6.4"]) if per_page.nil?
-        errors.add(:count, ErrorMessage["should be present if pagination is being used", "6.4"]) if count.nil?
-        errors.add(:pages, ErrorMessage["should be present if pagination is being used", "6.4"]) if pages.nil?
+        if current.nil?
+          errors.add(
+            :current,
+            ErrorMessage["should be present if pagination is being used", "6.4"]
+          )
+        end
+        if per_page.nil?
+          errors.add(
+            :per_page,
+            ErrorMessage["should be present if pagination is being used", "6.4"]
+          )
+        end
+        if count.nil?
+          errors.add(
+            :count,
+            ErrorMessage["should be present if pagination is being used", "6.4"]
+          )
+        end
+        return unless pages.nil?
+
+        errors.add(
+          :pages,
+          ErrorMessage["should be present if pagination is being used", "6.4"]
+        )
       end
 
       def previous_is_consistent
         if previous && current && previous != current - 1
-          errors.add(:previous, ErrorMessage["should be one less than current page number or null if first page", "6.4"])
+          errors.add(
+            :previous,
+            ErrorMessage["should be one less than current page number or null if first page", "6.4"]
+          )
         end
         if previous && current && current == 1
-          errors.add(:previous, ErrorMessage["should be null if on the first page", "6.4"])
-        end
-        if previous.nil? && current && current > 1
-          errors.add(:previous, ErrorMessage["can't be null if not on the first page", "6.4"])
+          errors.add(
+            :previous,
+            ErrorMessage["should be null if on the first page", "6.4"]
+          )
         end
+        return unless previous.nil? && current && current > 1
+
+        errors.add(
+          :previous,
+          ErrorMessage["can't be null if not on the first page", "6.4"]
+        )
       end
 
       def next_is_consistent
         if self.next && current && self.next != current + 1
-          errors.add(:next, ErrorMessage["should be one greater than current page number or null if last page", "6.4"])
+          errors.add(
+            :next,
+            ErrorMessage[
+              "should be one greater than current page number or null if last page",
+              "6.4"
+            ]
+          )
         end
         if self.next.nil? && current != pages
-          errors.add(:next, ErrorMessage["can't be null if not on the last page", "6.4"])
-        end
-        if self.next && current == pages
-          errors.add(:next, ErrorMessage["should be null if on the last page", "6.4"])
+          errors.add(
+            :next,
+            ErrorMessage["can't be null if not on the last page", "6.4"]
+          )
         end
+        return unless self.next && current == pages
+
+        errors.add(
+          :next,
+          ErrorMessage["should be null if on the last page", "6.4"]
+        )
       end
 
       def current_is_consistent
         if current && pages && current > pages
-          errors.add(:current, ErrorMessage["is larger than the number of pages", "6.4"])
-        end
-        if current && current < 1
-          errors.add(:current, ErrorMessage["can not be less than 1", "6.4"])
+          errors.add(
+            :current,
+            ErrorMessage["is larger than the number of pages", "6.4"]
+          )
         end
+        return unless current && current < 1
+
+        errors.add(
+          :current,
+          ErrorMessage["can not be less than 1", "6.4"]
+        )
       end
 
       def count_is_consistent
         if pages && per_page && count && count > pages * per_page
-          errors.add(:count, ErrorMessage["is larger than can be retrieved through paging", "6.4"])
-        end
-        if pages && per_page && count && count > 0 && count <= (pages - 1) * per_page
-          errors.add(:count, ErrorMessage["could fit into a smaller number of pages", "6.4"])
+          errors.add(
+            :count,
+            ErrorMessage["is larger than can be retrieved through paging", "6.4"]
+          )
         end
+        return unless pages &&
+                      per_page &&
+                      count &&
+                      count.positive? &&
+                      count <= (pages - 1) * per_page
+
+        errors.add(
+          :count,
+          ErrorMessage["could fit into a smaller number of pages", "6.4"]
+        )
       end
     end
   end

data/lib/atdis/models/person.rb

@@ -1,14 +1,16 @@
+# frozen_string_literal: true
+
 module ATDIS
   module Models
     class Person < Model
-      set_field_mappings ({
-        name:    String,
-        role:    String,
+      field_mappings(
+        name: String,
+        role: String,
         contact: String
-      })
+      )
 
       # Mandatory parameters
-      validates :name, :role, presence_before_type_cast: {spec_section: "4.3.6"}
+      validates :name, :role, presence_before_type_cast: { spec_section: "4.3.6" }
     end
   end
 end

data/lib/atdis/models/reference.rb

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 module ATDIS
   module Models
     class Reference < Model
-      set_field_mappings ({
+      field_mappings(
         more_info_url: URI,
-        comments_url:  URI
-      })
+        comments_url: URI
+      )
 
-      validates :more_info_url, presence_before_type_cast: {spec_section: "4.3.2"}
-      validates :more_info_url, :comments_url, http_url: {spec_section: "4.3.2"}
+      validates :more_info_url, presence_before_type_cast: { spec_section: "4.3.2" }
+      validates :more_info_url, :comments_url, http_url: { spec_section: "4.3.2" }
     end
   end
 end

data/lib/atdis/models/response.rb

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 require "atdis/models/application"
 
 module ATDIS
   module Models
     class Response < Model
-      set_field_mappings ({
+      field_mappings(
         application: Application
-      })
+      )
 
-      validates :application, presence_before_type_cast: {spec_section: "4.3"}
+      validates :application, presence_before_type_cast: { spec_section: "4.3" }
 
       # This model is only valid if the children are valid
       validates :application, valid: true

data/lib/atdis/models/torrens_title.rb

@@ -1,23 +1,25 @@
+# frozen_string_literal: true
+
 module ATDIS
   module Models
     class TorrensTitle < Model
-      set_field_mappings ({
-        lot:     String,
+      field_mappings(
+        lot: String,
         section: String,
         dpsp_id: String
-      })
+      )
 
       # Mandatory attributes
       # section is not in this list because it can be null (even though it is mandatory)
-      validates :lot, :dpsp_id, presence_before_type_cast: {spec_section: "4.3.3"}
+      validates :lot, :dpsp_id, presence_before_type_cast: { spec_section: "4.3.3" }
       # TODO: Provide warning if dpsp_id doesn't start with "DP" or "SP"
 
       validate :section_can_not_be_empty_string
 
       def section_can_not_be_empty_string
-        if section == ""
-          errors.add(:section, ATDIS::ErrorMessage.new("can't be blank", "4.3.3"))
-        end
+        return unless section == ""
+
+        errors.add(:section, ATDIS::ErrorMessage.new("can't be blank", "4.3.3"))
       end
     end
   end

data/lib/atdis/separated_url.rb

@@ -1,16 +1,18 @@
+# frozen_string_literal: true
+
 module ATDIS
   class SeparatedURL
-
     def self.merge(full_url, params)
       url, url_params = split(full_url)
       combine(url, url_params.merge(params))
     end
 
-    private
-    
     def self.combine(url, url_params)
       # Doing this jiggery pokery to ensure the params are sorted alphabetically (even on Ruby 1.8)
-      query = url_params.map{|k,v| [k.to_s, v]}.sort.map{|k,v| "#{CGI.escape(k)}=#{CGI.escape(v.to_s)}"}.join("&")
+      query = url_params.map { |k, v| [k.to_s, v] }
+                        .sort
+                        .map { |k, v| "#{CGI.escape(k)}=#{CGI.escape(v.to_s)}" }
+                        .join("&")
       if url_params.empty?
         url
       else
@@ -20,18 +22,18 @@ module ATDIS
 
     def self.split(full_url)
       uri = URI.parse(full_url)
-      if (uri.scheme == "http" && uri.port == 80) || (uri.scheme == "https" && uri.port == 443)
-        url = "#{uri.scheme}://#{uri.host}#{uri.path}"
-      else
-        url = "#{uri.scheme}://#{uri.host}:#{uri.port}#{uri.path}"
-      end
-      if uri.query
-        url_params = Hash[*CGI::parse(uri.query).map{|k,v| [k.to_sym,v.first]}.flatten]
-      else
-        url_params = {}
-      end
+      url = if (uri.scheme == "http" && uri.port == 80) ||
+               (uri.scheme == "https" && uri.port == 443)
+              "#{uri.scheme}://#{uri.host}#{uri.path}"
+            else
+              "#{uri.scheme}://#{uri.host}:#{uri.port}#{uri.path}"
+            end
+      url_params = if uri.query
+                     Hash[*CGI.parse(uri.query).map { |k, v| [k.to_sym, v.first] }.flatten]
+                   else
+                     {}
+                   end
       [url, url_params]
     end
-
   end
 end

data/lib/atdis/validators.rb

@@ -1,93 +1,100 @@
-require 'active_model'
+# frozen_string_literal: true
+
+require "active_model"
 
 module ATDIS
   module Validators
     class GeoJsonValidator < ActiveModel::EachValidator
       def validate_each(record, attribute, value)
         raw_value = record.send("#{attribute}_before_type_cast")
-        if raw_value.present? && value.nil?
-          message = "is not valid GeoJSON"
-          message = ErrorMessage[message, options[:spec_section]] if options[:spec_section]
-          record.errors.add(attribute, message)
-        end
+        return unless raw_value.present? && value.nil?
+
+        message = "is not valid GeoJSON"
+        message = ErrorMessage[message, options[:spec_section]] if options[:spec_section]
+        record.errors.add(attribute, message)
       end
     end
 
     class DateTimeValidator < ActiveModel::EachValidator
       def validate_each(record, attribute, value)
         raw_value = record.send("#{attribute}_before_type_cast")
-        if raw_value.present? && !value.kind_of?(DateTime)
-          record.errors.add(attribute, ErrorMessage["is not a valid date", options[:spec_section]])
-        end
+        return unless raw_value.present? && !value.is_a?(DateTime)
+
+        record.errors.add(attribute, ErrorMessage["is not a valid date", options[:spec_section]])
       end
     end
 
     class HttpUrlValidator < ActiveModel::EachValidator
       def validate_each(record, attribute, value)
         raw_value = record.send("#{attribute}_before_type_cast")
-        if raw_value.present? && !value.kind_of?(URI::HTTP) && !value.kind_of?(URI::HTTPS)
-          message = "is not a valid URL"
-          message = ErrorMessage[message, options[:spec_section]] if options[:spec_section]
-          record.errors.add(attribute, message)
-        end
+        return unless raw_value.present? && !value.is_a?(URI::HTTP) && !value.is_a?(URI::HTTPS)
+
+        message = "is not a valid URL"
+        message = ErrorMessage[message, options[:spec_section]] if options[:spec_section]
+        record.errors.add(attribute, message)
       end
     end
 
     class ArrayHttpUrlValidator < ActiveModel::EachValidator
       def validate_each(record, attribute, value)
-        if value.present? && value.kind_of?(Array) &&
-          value.any?{|v| !v.kind_of?(URI::HTTP) && !v.kind_of?(URI::HTTPS)}
-            message = "contains an invalid URL"
-            message = ErrorMessage[message, options[:spec_section]] if options[:spec_section]
-            record.errors.add(attribute, message)
+        if value.present? &&
+           value.is_a?(Array) &&
+           value.any? { |v| !v.is_a?(URI::HTTP) && !v.is_a?(URI::HTTPS) }
+          message = "contains an invalid URL"
+          message = ErrorMessage[message, options[:spec_section]] if options[:spec_section]
+          record.errors.add(attribute, message)
         end
       end
     end
 
     class ArrayValidator < ActiveModel::EachValidator
       def validate_each(record, attribute, value)
-        if value && !value.kind_of?(Array)
-          message = "should be an array"
-          message = ErrorMessage[message, options[:spec_section]] if options[:spec_section]
-          record.errors.add(attribute, message)
-        end
+        return unless value && !value.is_a?(Array)
+
+        message = "should be an array"
+        message = ErrorMessage[message, options[:spec_section]] if options[:spec_section]
+        record.errors.add(attribute, message)
       end
     end
 
     # Can't be an empty array
     class FilledArrayValidator < ActiveModel::EachValidator
       def validate_each(record, attribute, value)
-        if value && !value.kind_of?(Array)
+        if value && !value.is_a?(Array)
           message = "should be an array"
           message = ErrorMessage[message, options[:spec_section]] if options[:spec_section]
           record.errors.add(attribute, message)
         end
-        if value && value.kind_of?(Array) && value.empty?
-          message = "should not be an empty array"
-          message = ErrorMessage[message, options[:spec_section]] if options[:spec_section]
-          record.errors.add(attribute, message)
-        end
+        return unless value&.is_a?(Array) && value&.empty?
+
+        message = "should not be an empty array"
+        message = ErrorMessage[message, options[:spec_section]] if options[:spec_section]
+        record.errors.add(attribute, message)
       end
     end
 
     # Take into account the value before type casting
     class PresenceBeforeTypeCastValidator < ActiveModel::EachValidator
-      def validate_each(record, attribute, value)
+      def validate_each(record, attribute, _value)
         raw_value = record.send("#{attribute}_before_type_cast")
-        if !raw_value.kind_of?(Array) && !raw_value.present?
-          message = "can't be blank"
-          message = ErrorMessage[message, options[:spec_section]] if options[:spec_section]
-          record.errors.add(attribute, message)
-        end
+        return unless !raw_value.is_a?(Array) && !raw_value.present?
+
+        message = "can't be blank"
+        message = ErrorMessage[message, options[:spec_section]] if options[:spec_section]
+        record.errors.add(attribute, message)
       end
     end
 
     # This attribute itself needs to be valid
     class ValidValidator < ActiveModel::EachValidator
       def validate_each(record, attribute, value)
-        if (value.respond_to?(:valid?) && !value.valid?) || (value && !value.respond_to?(:valid?) && !value.all?{|v| v.valid?})
-          record.errors.add(attribute, ErrorMessage["is not valid (see further errors for details)", nil])
-        end
+        return unless (value.respond_to?(:valid?) && !value.valid?) ||
+                      (value && !value.respond_to?(:valid?) && !value.all?(&:valid?))
+
+        record.errors.add(
+          attribute,
+          ErrorMessage["is not valid (see further errors for details)", nil]
+        )
       end
     end
   end