atdis 0.3.13 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 115d598c77fb6437ed05614cadc31664786185e4
-  data.tar.gz: 30ac0686681de9748e37171f360d63e72786126d
+  metadata.gz: 0c42c8984e3515ca6f1a98e02e774cfbf30b28e9
+  data.tar.gz: e3fd6b0fa426195259d1b392dda98f55d5f9c9b7
 SHA512:
-  metadata.gz: 502e18e86ed22d0fb1b34130902716ba4c8c020cc1ed1bda8ac8b7c91dc539512a8dbf6cfa49cbe6910b85df6a88cdc0909d1b1f0b35eca2f33f257e359952a9
-  data.tar.gz: f30ae1357c7c3f9db5188a1703822b759c805fe9d929443a1751395ed58dccad946e083f06bd7419eea4e733af3faff73cdf15ce463c2b4aa12727a46c00c070
+  metadata.gz: 6ebeaa70b6b9eb739cd47aa8c8b9bec5b8d15b71efb99b6263c1327cab6a2b84866a2b304959d65542b9a1a94580b55445bd417f8fe302ae2708c2c45d5d27f6
+  data.tar.gz: 4d72b3a0621f1d40fbaf0cf517cf35b7f1d17817422ede3273d22d0f5de2ec008456612337131b649916b45872fe3afb0b97970eae2e72a9870ed17b86fb3b6f

data/.rubocop.yml

@@ -0,0 +1,46 @@
+# Bumping max line length to something a little more reasonable
+Metrics/LineLength:
+  Max: 100
+
+# Not so worried about top-level class documentation. So...
+Style/Documentation:
+  Enabled: false
+
+# We prefer double quotes here and it we're making liberal use of multi-line
+# strings so it makes sense to enforce those to be consistent oo
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+  ConsistentQuotesInMultiline: true
+
+# This one I disagree with. Putting seperators in large numbers makes sense
+# in some circumstances but in others (an example id in a database table)
+# it's just nonsensical. Also, I think this one might also be a bit US centric.
+Style/NumericLiterals:
+  Enabled: false
+
+# Disable a bunch of metrics to do with code complexity. These as are all
+# a bit hard-nosed. Maybe after we've done a pass with Code Climate we
+# can revisit these
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/ModuleLength:
+  Enabled: false
+
+Metrics/ParameterLists:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false

data/.ruby-version

@@ -1 +1 @@
-ruby-2.0.0-p353
+ruby-2.3.1

data/Gemfile

@@ -1,14 +1,16 @@
-source 'https://rubygems.org'
+# frozen_string_literal: true
+
+source "https://rubygems.org"
 
 group :development do
+  gem "coveralls", require: false
+  gem "growl"
+  gem "guard"
+  gem "guard-rspec"
+  gem "rb-fsevent", "~> 0.9"
   gem "rspec"
-  gem 'guard'
-  gem 'guard-rspec'
-  gem 'growl'
-  gem 'rb-fsevent', '~> 0.9'
   # Probably required on OS X. See https://github.com/guard/guard/wiki/Add-Readline-support-to-Ruby-on-Mac-OS-X
-  gem 'rb-readline'
-  gem 'coveralls', require: false
+  gem "rb-readline"
 end
 
 # Specify your gem's dependencies in atdis.gemspec

data/Guardfile

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
+
 # More info at https://github.com/guard/guard#readme
 
-guard 'rspec' do
-  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+guard "rspec" do
+  watch(%r{^lib/(.+)\.rb$}) { |m| "spec/#{m[1]}_spec.rb" }
   watch(%r{^spec/.+_spec\.rb$})
 end
-

data/Rakefile

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require "bundler/gem_tasks"
 
-require 'rspec/core/rake_task'
+require "rspec/core/rake_task"
 
-RSpec::Core::RakeTask.new('spec')
+RSpec::Core::RakeTask.new("spec")
 
 # If you want to make this the default task
 task default: :spec

data/atdis.gemspec

@@ -1,14 +1,16 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'atdis/version'
+require "atdis/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "atdis"
   spec.version       = Atdis::VERSION
   spec.authors       = ["Matthew Landauer"]
   spec.email         = ["matthew@openaustraliafoundation.org.au"]
-  spec.description   = %q{A ruby interface to the application tracking data interchange specification (ATDIS) API}
+  spec.description   =
+    "A ruby interface to the application tracking data interchange specification (ATDIS) API"
   spec.summary       = spec.description
   spec.homepage      = "http://github.com/openaustralia/atdis"
   spec.license       = "MIT"
@@ -17,12 +19,15 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
+  spec.required_ruby_version = ">= 2.3.1"
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency "rubocop"
 
+  spec.add_dependency "activemodel"
+  spec.add_dependency "activesupport"
   spec.add_dependency "multi_json", "~> 1.7"
   spec.add_dependency "rest-client"
   spec.add_dependency "rgeo-geojson"
-  spec.add_dependency "activemodel"
 end

data/lib/atdis.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "atdis/version"
 
 require "atdis/validators"

data/lib/atdis/feed.rb

@@ -1,23 +1,33 @@
+# frozen_string_literal: true
+
 require "rest-client"
 
 module ATDIS
   class Feed
-    attr_reader :base_url
+    attr_reader :base_url, :timezone
 
-    VALID_OPTIONS = [:page, :street, :suburb, :postcode, :lodgement_date_start, :lodgement_date_end, :last_modified_date_start, :last_modified_date_end]
+    VALID_OPTIONS = %i[page street suburb postcode lodgement_date_start
+                       lodgement_date_end last_modified_date_start last_modified_date_end].freeze
 
     # base_url - the base url from which the urls for all atdis urls are made
     # It should be of the form:
     # http://www.council.nsw.gov.au/atdis/1.0
-    def initialize(base_url)
+    # timezone - a string (e.g. "Sydney") for the timezone in which times are returned
+    # (Note: times in the feeds that have timezones specified get converted to the
+    # timezone given while times in the feed which don't have a timezone specified
+    # get interpreted in the given timezone)
+    # See https://api.rubyonrails.org/classes/ActiveSupport/TimeZone.html for the
+    # list of possible timezone strings
+    def initialize(base_url, timezone)
       @base_url = base_url
+      @timezone = timezone
     end
 
     def applications_url(options = {})
       invalid_options = options.keys - VALID_OPTIONS
-      if !invalid_options.empty?
-        raise "Unexpected options used: #{invalid_options.join(',')}"
-      end
+
+      raise "Unexpected options used: #{invalid_options.join(',')}" unless invalid_options.empty?
+
       options[:street] = options[:street].join(",") if options[:street].respond_to?(:join)
       options[:suburb] = options[:suburb].join(",") if options[:suburb].respond_to?(:join)
       options[:postcode] = options[:postcode].join(",") if options[:postcode].respond_to?(:join)
@@ -27,7 +37,7 @@ module ATDIS
     end
 
     def application_url(id)
-      "#{base_url}/#{CGI::escape(id)}.json"
+      "#{base_url}/#{CGI.escape(id)}.json"
     end
 
     def self.base_url_from_url(url)
@@ -45,44 +55,39 @@ module ATDIS
     def self.options_from_url(url)
       u = URI.parse(url)
       options = query_to_options(u.query)
-      [:lodgement_date_start, :lodgement_date_end, :last_modified_date_start, :last_modified_date_end].each do |k|
+      %i[lodgement_date_start lodgement_date_end last_modified_date_start
+         last_modified_date_end].each do |k|
         options[k] = Date.parse(options[k]) if options[k]
       end
       options[:page] = options[:page].to_i if options[:page]
       # Remove invalid options
-      options.keys.each do |key|
-        if !VALID_OPTIONS.include?(key)
-          options.delete(key)
-        end
+      options.each_key do |key|
+        options.delete(key) unless VALID_OPTIONS.include?(key)
       end
       options
     end
 
     def applications(options = {})
-      Models::Page.read_url(applications_url(options))
+      Models::Page.read_url(applications_url(options), timezone)
     end
 
     def application(id)
-      Models::Application.read_url(application_url(id))
+      Models::Application.read_url(application_url(id), timezone)
     end
 
-    private
-
     # Turn a query string of the form "foo=bar&hello=sir" to {foo: "bar", hello: sir"}
     def self.query_to_options(query)
       options = {}
-      if query
-        query.split("&").each do |t|
-          key, value = t.split("=")
-          options[key.to_sym] = (CGI::unescape(value) if value)
-        end
+      (query || "").split("&").each do |t|
+        key, value = t.split("=")
+        options[key.to_sym] = (CGI.unescape(value) if value)
       end
       options
     end
 
     # Escape but leave commas unchanged (which are valid in query strings)
-    def self.escape(v)
-      CGI::escape(v.to_s).gsub('%2C',',')
+    def self.escape(value)
+      CGI.escape(value.to_s).gsub("%2C", ",")
     end
 
     # Turn an options hash of the form {foo: "bar", hello: "sir"} into a query
@@ -91,7 +96,9 @@ module ATDIS
       if options.empty?
         nil
       else
-        options.sort{|a,b| a.first.to_s <=> b.first.to_s}.map{|k,v| "#{k}=#{escape(v)}"}.join("&")
+        options.sort { |a, b| a.first.to_s <=> b.first.to_s }
+               .map { |k, v| "#{k}=#{escape(v)}" }
+               .join("&")
       end
     end
   end

data/lib/atdis/model.rb

@@ -1,6 +1,8 @@
-require 'multi_json'
-require 'active_model'
-require 'date'
+# frozen_string_literal: true
+
+require "multi_json"
+require "active_model"
+require "date"
 
 module ATDIS
   module TypeCastAttributes
@@ -11,14 +13,14 @@ module ATDIS
     end
 
     module ClassMethods
-      # of the form {section: Fixnum, address: String}
-      def set_field_mappings(p)
-        define_attribute_methods(p.keys.map{|k| k.to_s})
+      # of the form {section: Integer, address: String}
+      def field_mappings(params)
+        define_attribute_methods(params.keys.map(&:to_s))
         # Convert all values to arrays. Doing this for the sake of tidier notation
         self.attribute_types = {}
-        p.each do |k,v|
-          v = [v] unless v.kind_of?(Array)
-          self.attribute_types[k] = v
+        params.each do |k, v|
+          v = [v] unless v.is_a?(Array)
+          attribute_types[k] = v
         end
       end
     end
@@ -40,10 +42,10 @@ module ATDIS
     include Validators
     include ActiveModel::AttributeMethods
     include TypeCastAttributes
-    attribute_method_suffix '_before_type_cast'
-    attribute_method_suffix '='
+    attribute_method_suffix "_before_type_cast"
+    attribute_method_suffix "="
 
-    attr_reader :attributes, :attributes_before_type_cast
+    attr_reader :attributes, :attributes_before_type_cast, :timezone
     # Stores any part of the json that could not be interpreted. Usually
     # signals an error if it isn't empty.
     attr_accessor :json_left_overs, :json_load_error
@@ -54,7 +56,8 @@ module ATDIS
 
     # Partition the data into used and unused by returning [used, unused]
     def self.partition_by_used(data)
-      used, unused = {}, {}
+      used = {}
+      unused = {}
       if data.respond_to?(:each)
         data.each do |key, value|
           if attribute_keys.include?(key)
@@ -69,46 +72,47 @@ module ATDIS
       [used, unused]
     end
 
-    def self.read_url(url)
-      r = read_json(RestClient.get(url.to_s).to_str)
+    def self.read_url(url, timezone)
+      r = read_json(RestClient.get(url.to_s).to_str, timezone)
       r.url = url.to_s
       r
     end
 
-    def self.read_json(text)
-      begin
-        data = MultiJson.load(text, symbolize_keys: true)
-        interpret(data)
-      rescue MultiJson::LoadError => e
-        a = interpret({response: []})
-        a.json_load_error = e.to_s
-        a
-      end
+    def self.read_json(text, timezone)
+      data = MultiJson.load(text, symbolize_keys: true)
+      interpret(data, timezone)
+    rescue MultiJson::LoadError => e
+      a = interpret({ response: [] }, timezone)
+      a.json_load_error = e.to_s
+      a
     end
 
-    def self.interpret(*params)
-      used, unused = partition_by_used(*params)
-      new(used.merge(json_left_overs: unused))
+    def self.interpret(data, timezone)
+      used, unused = partition_by_used(data)
+      new(used.merge(json_left_overs: unused), timezone)
     end
 
     def json_loaded_correctly!
-      if json_load_error
-        errors.add(:json, ErrorMessage["Invalid JSON: #{json_load_error}", nil])
-      end
+      return unless json_load_error
+
+      errors.add(:json, ErrorMessage["Invalid JSON: #{json_load_error}", nil])
     end
 
     def json_errors_local
       r = []
       # First show special json error
-      if !errors[:json].empty?
-        r << [nil, errors[:json]]
-      end
       errors.keys.each do |attribute|
+        r << [nil, errors[:json]] unless errors[:json].empty?
         # The :json attribute is special
-        if attribute != :json
-          e = errors[attribute]
-          r << [{attribute => attributes_before_type_cast[attribute.to_s]}, e.map{|m| ErrorMessage["#{attribute} #{m}", m.spec_section]}] unless e.empty?
-        end
+        next if attribute == :json
+
+        e = errors[attribute]
+        next if e.empty?
+
+        r << [
+          { attribute => attributes_before_type_cast[attribute.to_s] },
+          e.map { |m| ErrorMessage["#{attribute} #{m}", m.spec_section] }
+        ]
       end
       r
     end
@@ -117,12 +121,11 @@ module ATDIS
       r = []
       attributes.each do |attribute_as_string, value|
         attribute = attribute_as_string.to_sym
-        e = errors[attribute]
         if value.respond_to?(:json_errors)
-           r += value.json_errors.map{|a, b| [{attribute => a}, b]}
-        elsif value.kind_of?(Array)
-          f = value.find{|v| v.respond_to?(:json_errors) && !v.json_errors.empty?}
-          r += f.json_errors.map{|a, b| [{attribute => [a]}, b]} if f
+          r += value.json_errors.map { |a, b| [{ attribute => a }, b] }
+        elsif value.is_a?(Array)
+          f = value.find { |v| v.respond_to?(:json_errors) && !v.json_errors.empty? }
+          r += f.json_errors.map { |a, b| [{ attribute => [a] }, b] } if f
         end
       end
       r
@@ -133,22 +136,29 @@ module ATDIS
     end
 
     # Have we tried to use this attribute?
-    def used_attribute?(a)
-      !attributes_before_type_cast[a].nil?
+    def used_attribute?(attribute)
+      !attributes_before_type_cast[attribute].nil?
     end
 
     def json_left_overs_is_empty
-      if json_left_overs && !json_left_overs.empty?
-        # We have extra parameters that shouldn't be there
-        errors.add(:json, ErrorMessage["Unexpected parameters in json data: #{MultiJson.dump(json_left_overs)}", "4"])
-      end
+      return unless json_left_overs && !json_left_overs.empty?
+
+      # We have extra parameters that shouldn't be there
+      errors.add(
+        :json,
+        ErrorMessage["Unexpected parameters in json data: #{MultiJson.dump(json_left_overs)}", "4"]
+      )
     end
 
-    def initialize(params={})
-      @attributes, @attributes_before_type_cast = {}, {}
+    def initialize(params, timezone)
+      @timezone = timezone
+      @attributes = {}
+      @attributes_before_type_cast = {}
+      return unless params
+
       params.each do |attr, value|
-        self.send("#{attr}=", value)
-      end if params
+        send("#{attr}=", value)
+      end
     end
 
     def self.attribute_keys
@@ -157,72 +167,49 @@ module ATDIS
 
     # Does what the equivalent on Activerecord does
     def self.attribute_names
-      attribute_types.keys.map{|k| k.to_s}
+      attribute_types.keys.map(&:to_s)
     end
 
-    def self.cast(value, type)
+    def self.cast(value, type, timezone)
       # If it's already the correct type (or nil) then we don't need to do anything
-      if value.nil? || value.kind_of?(type)
+      if value.nil? || value.is_a?(type)
         value
-      # Special handling for arrays. When we typecast arrays we actually typecast each member of the array
-      elsif value.kind_of?(Array)
-        value.map {|v| cast(v, type)}
+      # Special handling for arrays. When we typecast arrays we actually
+      # typecast each member of the array
+      elsif value.is_a?(Array)
+        value.map { |v| cast(v, type, timezone) }
       elsif type == DateTime
-        cast_datetime(value)
+        cast_datetime(value, timezone)
       elsif type == URI
         cast_uri(value)
       elsif type == String
         cast_string(value)
-      elsif type == Fixnum
-        cast_fixnum(value)
+      elsif type == Integer
+        cast_integer(value)
       elsif type == RGeo::GeoJSON
         cast_geojson(value)
       # Otherwise try to use Type.interpret to do the typecasting
       elsif type.respond_to?(:interpret)
-        type.interpret(value) if value
+        type.interpret(value, timezone) if value
       else
         raise
       end
     end
 
-    private
-
-    def attribute(attr)
-      @attributes[attr]
-    end
-
-    def attribute_before_type_cast(attr)
-      @attributes_before_type_cast[attr]
-    end
-
-    def attribute=(attr, value)
-      @attributes_before_type_cast[attr] = value
-      @attributes[attr] = Model.cast(value, attribute_types[attr.to_sym][0])
-    end
-
-    def self.cast_datetime(value)
-      # This would be much easier if we knew we only had to support Ruby 1.9 or greater because it has
-      # an implementation built in. Because for the time being we need to support Ruby 1.8 as well
-      # we'll build an implementation of parsing by hand. Ugh.
-      # Referencing http://www.w3.org/TR/NOTE-datetime
-      # In section 4.3.1 of ATDIS 1.0.4 it shows two variants of iso 8601, either the full date
-      # or the full date with hours, seconds, minutes and timezone. We'll assume that these
-      # are the two variants that are allowed.
-      if value.respond_to?(:match) && value.match(/^\d\d\d\d-\d\d-\d\d(T\d\d:\d\d:\d\d(Z|(\+|-)\d\d:\d\d))?$/)
-        begin
-          DateTime.parse(value)
-        rescue ArgumentError
-          nil
-        end
-      end
+    # If timezone is given in the string then the datetime is read in using
+    # the timezone in the string and then converted to the timezone "zone"
+    # If the timezone isn't given in the string then the datetime is read
+    # in using the timezone in "zone"
+    def self.cast_datetime(value, timezone)
+      ActiveSupport::TimeZone.new(timezone).iso8601(value).to_datetime
+    rescue ArgumentError, KeyError
+      nil
     end
 
     def self.cast_uri(value)
-      begin
-        URI.parse(value)
-      rescue URI::InvalidURIError
-        nil
-      end
+      URI.parse(value)
+    rescue URI::InvalidURIError
+      nil
     end
 
     def self.cast_string(value)
@@ -230,8 +217,8 @@ module ATDIS
     end
 
     # This casting allows nil values
-    def self.cast_fixnum(value)
-      value.to_i if value
+    def self.cast_integer(value)
+      value&.to_i
     end
 
     def self.cast_geojson(value)
@@ -250,5 +237,20 @@ module ATDIS
         hash
       end
     end
+
+    private
+
+    def attribute(attr)
+      @attributes[attr]
+    end
+
+    def attribute_before_type_cast(attr)
+      @attributes_before_type_cast[attr]
+    end
+
+    def attribute=(attr, value)
+      @attributes_before_type_cast[attr] = value
+      @attributes[attr] = Model.cast(value, attribute_types[attr.to_sym][0], timezone)
+    end
   end
 end