atdis 0.2 → 0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2b0835df894665d409ea7c29c71f70158e4a4d66
+  data.tar.gz: 07d56dc629ee7916e72388bd881b29952a0b629c
+SHA512:
+  metadata.gz: 60c9f8efc76ea97d526acd9f8044878b42baefab92c7ea2939e5987e0a38403b04681a384852d067c584343a60a7209b676702f71fed7bcb205ab1275904244f
+  data.tar.gz: 451d11c16ec89abaa8d6660cd83ba9f91001d97b0f11624b333890eb7c8291bf526cab2784c1c3623d38f2d3d3383ddc29071e17cc5957b887c7692f56c27bb3

data/.ruby-version

@@ -1 +1 @@
-ruby-1.8.7-p370
+ruby-2.0.0-p353

data/.travis.yml

@@ -1,6 +1,5 @@
 language: ruby
 rvm:
-  - "1.8.7"
   - "1.9.3"
   - "2.0.0"
 # uncomment this line if your project needs to run something other than `rake`:

data/Gemfile

@@ -8,7 +8,7 @@ group :development do
   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 'coveralls', require: false
 end
 
 # Specify your gem's dependencies in atdis.gemspec

data/README.md

@@ -6,7 +6,7 @@ A ruby interface to the application tracking data interchange specification (ATD
 
 We're developing this against version ATDIS 1.0.7.
 
-This is **highly alpha** software that probably doesn't yet do what it says on the tin. It is very much a work in progress.
+This is **beta** software and is a work in progress.
 
 Source code is available on GitHub at https://github.com/openaustralia/atdis
 
@@ -26,7 +26,30 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+### Basic usage
+
+    require 'atdis'
+    f = ATDIS::Feed.new("http://www.planningalerts.org.au/atdis/feed/1/atdis/1.0")
+
+    # Get the first application in the first page of results for all the applications
+    page = f.applications
+    app = page.response.first
+
+    puts "#{app.dat_id}: #{app.description} at #{app.location.address}"
+
+    DA2013-0381: New pool plus deck at 123 Fourfivesix Street Neutral Bay NSW 2089
+
+### Paging
+
+    page.next_page
+
+and
+
+    page.previous_page
+
+### Validation
+
+    page.valid?
 
 ## Contributing
 

data/Rakefile

@@ -5,4 +5,4 @@ require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new('spec')
 
 # If you want to make this the default task
-task :default => :spec
+task default: :spec

data/lib/atdis.rb

@@ -1,12 +1,7 @@
 require "atdis/version"
 
 require "atdis/validators"
-require "atdis/model"
-require "atdis/event"
-require "atdis/document"
-require "atdis/location"
-require "atdis/person"
-require "atdis/application"
 require "atdis/feed"
-require "atdis/page"
 require "atdis/separated_url"
+require "atdis/model"
+require "atdis/models/page"

data/lib/atdis/feed.rb

@@ -4,18 +4,90 @@ module ATDIS
   class Feed
     attr_reader :base_url
 
+    VALID_OPTIONS = [:page, :street, :suburb, :postcode, :lodgement_date_start, :lodgement_date_end, :last_modified_date_start, :last_modified_date_end]
+
     # base_url - the base url from which the urls for all atdis urls are made
-    # It is the concatenation of the protocol and web address as defined in section 4.2 of specification
-    # For example if the base_url is "http://www.council.nsw.gov.au" then the url for listing all the
-    # applications is "http://www.council.nsw.gov.au/atdis/1.0/applications.json"
+    # It should be of the form:
+    # http://www.council.nsw.gov.au/atdis/1.0
     def initialize(base_url)
-      @base_url = base_url.kind_of?(URI) ? base_url : URI.parse(base_url)
+      @base_url = base_url
+    end
+
+    def applications_url(options = {})
+      invalid_options = options.keys - VALID_OPTIONS
+      if !invalid_options.empty?
+        raise "Unexpected options used: #{invalid_options.join(',')}"
+      end
+      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)
+
+      q = Feed.options_to_query(options)
+      "#{base_url}/applications.json" + (q ? "?#{q}" : "")
+    end
+
+    def application_url(id)
+      "#{base_url}/#{CGI::escape(id)}.json"
+    end
+
+    def self.base_url_from_url(url)
+      u = URI.parse(url)
+      options = query_to_options(u.query)
+      VALID_OPTIONS.each do |o|
+        options.delete(o)
+      end
+      u.query = options_to_query(options)
+      u.fragment = nil
+      u.path = "/" + u.path.split("/")[1..-2].join("/")
+      u.to_s
+    end
+
+    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|
+        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
+      end
+      options
+    end
+
+    def applications(options = {})
+      Models::Page.read_url(applications_url(options))
+    end
+
+    def application(id)
+      Models::Application.read_url(application_url(id))
+    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] = value
+        end
+      end
+      options
     end
 
-    def applications(page = 1)
-      url = base_url + "atdis/1.0/applications.json"
-      url += "?page=#{page}" if page > 1
-      Page.read_url(url)
+    # Turn an options hash of the form {foo: "bar", hello: "sir"} into a query
+    # string of the form "foo=bar&hello=sir"
+    def self.options_to_query(options)
+      if options.empty?
+        nil
+      else
+        options.sort{|a,b| a.first.to_s <=> b.first.to_s}.map{|k,v| "#{k}=#{v}"}.join("&")
+      end
     end
   end
 end

data/lib/atdis/model.rb

@@ -7,46 +7,18 @@ module ATDIS
 
     included do
       class_attribute :attribute_types
-      class_attribute :field_mappings
     end
 
     module ClassMethods
-      # of the form {:section=>[String, {:none_is_nil=>true}], :address=>[String]}
-      def casting_attributes(p)
-        define_attribute_methods(p.keys.map{|k| k.to_s})
-        self.attribute_types = p
-      end
-
+      # of the form {section: Fixnum, address: String}
       def set_field_mappings(p)
-        a, b = translate_field_mappings(p)
-        # field_mappings is of the form {:pagination=>{:previous=>:previous_page_no, :pages=>:total_no_pages}}
-        self.field_mappings = a
-        casting_attributes(b)
-      end
-
-      private
-
-      def leaf_array?(v)
-        if !v.kind_of?(Array)
-          return false
-        end
-        v.all?{|a| !a.kind_of?(Array)}
-      end
-      
-      def translate_field_mappings(p)
-        f = ActiveSupport::OrderedHash.new
-        ca = ActiveSupport::OrderedHash.new
+        define_attribute_methods(p.keys.map{|k| k.to_s})
+        # Convert all values to arrays. Doing this for the sake of tidier notation
+        self.attribute_types = {}
         p.each do |k,v|
-          if leaf_array?(v)
-            f[k] = v[0]
-            ca[v.first] = v[1..-1]
-          else
-            f2, ca2 = translate_field_mappings(v)
-            f[k] = f2
-            ca = ca.merge(ca2)
-          end
+          v = [v] unless v.kind_of?(Array)
+          self.attribute_types[k] = v
         end
-        [f, ca]
       end
     end
   end
@@ -74,105 +46,89 @@ module ATDIS
     # 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
-    
-    validate :json_left_overs_is_empty
+    attr_accessor :url
 
-    def self.level_attribute_names(level)
-      attribute_types.find_all{|k,v| (v[1] || {})[:level] == level }.map{|k,v| k.to_s}
-    end
+    validate :json_loaded_correctly!
+    validate :json_left_overs_is_empty
 
-    def json_attribute(a, new_value, mappings = field_mappings)
-      mappings.each do |attribute, v|
-        if v == a
-          return {attribute => new_value}
-        end
-        if v.kind_of?(Hash)
-          r = json_attribute(a, new_value, v)
-          if r
-            return {attribute => r}
+    # Partition the data into used and unused by returning [used, unused]
+    def self.partition_by_used(data)
+      used, unused = {}, {}
+      if data.respond_to?(:each)
+        data.each do |key, value|
+          if attribute_keys.include?(key)
+            used[key] = value
+          else
+            unused[key] = value
           end
         end
+      else
+        unused = data
       end
-      nil
+      [used, unused]
     end
 
-    def self.map_field(key, data, mappings)
-      mappings.each do |k, v|
-        if v == key
-          return data[k]
-        elsif v.kind_of?(Hash) && data.has_key?(k)
-          r = map_field(key, data[k], mappings[k])
-          if r
-            return r
-          end
-        end
-      end
-      nil
+    def self.read_url(url)
+      r = read_json(RestClient.get(url.to_s).to_str)
+      r.url = url.to_s
+      r
     end
 
-    def self.unused_data(data, mappings = field_mappings)
-      json_left_overs = {}
-      data.each_key do |key|
-        if mappings[key]
-          if mappings[key].kind_of?(Hash)
-            l2 = unused_data(data[key], mappings[key])
-            json_left_overs[key] = l2 unless l2.empty?
-          end
-        else
-          json_left_overs[key] = data[key]
-        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
-      json_left_overs
     end
 
-    def self.attribute_names_from_mappings(mappings)
-      result = []
-      mappings.each do |k, v|
-        if v.kind_of?(Hash)
-          result += attribute_names_from_mappings(v)
-        else
-          result << v
-        end
-      end
-      result
+    def self.interpret(*params)
+      used, unused = partition_by_used(*params)
+      new(used.merge(json_left_overs: unused))
     end
 
-    # Map json structure to our values
-    def self.map_fields(data, mappings = field_mappings)
-      values = {}
-      attribute_names_from_mappings(mappings).each do |attribute|
-        values[attribute] = map_field(attribute, data, mappings)
+    def json_loaded_correctly!
+      if json_load_error
+        errors.add(:json, ErrorMessage["Invalid JSON: #{json_load_error}", nil])
       end
-      values
     end
 
-    def json_errors
+    def json_errors_local
       r = []
-      errors.messages.each do |attribute, e|
-        value = attributes[attribute.to_s]
-        if (value.respond_to?(:valid?) && !value.valid?)
-          r += value.json_errors.map{|a, b| [json_attribute(attribute, a), b]}
-        elsif (value && !value.respond_to?(:valid?) && value.respond_to?(:all?) && !value.all?{|v| v.valid?})
-          f = value.find{|v| !v.valid?}
-          r += f.json_errors.map{|a, b| [json_attribute(attribute, a), b]}
-        else
-          r << [json_attribute(attribute, attributes_before_type_cast[attribute.to_s]), e]
+      # First show special json error
+      if !errors[:json].empty?
+        r << [nil, errors[:json]]
+      end
+      errors.keys.each do |attribute|
+        # 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
       end
       r
     end
 
-    # TODO This is doing a similar stepping down into the children that json_errors is doing. Would be nice
-    # to extract the commond code to make this less horrible and arbitrary
-    def level_used_in_children?(level)
-      attributes.each_value do |a|
-        if a.respond_to?(:level_used?) && a.level_used?(level)
-          return true
-        elsif a.kind_of?(Array) && a.any?{|b| b.level_used?(level)}
-          return true
+    def json_errors_in_children
+      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
         end
       end
-      false
+      r
+    end
+
+    def json_errors
+      json_errors_local + json_errors_in_children
     end
 
     # Have we tried to use this attribute?
@@ -180,14 +136,6 @@ module ATDIS
       !attributes_before_type_cast[a].nil?
     end
 
-    def level_used_locally?(level)
-      self.class.level_attribute_names(level).any?{|a| used_attribute?(a)}
-    end
-
-    def level_used?(level)
-      level_used_locally?(level) || level_used_in_children?(level)
-    end
-
     def json_left_overs_is_empty
       if json_left_overs && !json_left_overs.empty?
         # We have extra parameters that shouldn't be there
@@ -202,24 +150,22 @@ module ATDIS
       end if params
     end
 
+    def self.attribute_keys
+      attribute_types.keys
+    end
+
     # Does what the equivalent on Activerecord does
     def self.attribute_names
       attribute_types.keys.map{|k| k.to_s}
     end
 
-    def self.interpret(*params)
-      new(map_fields(*params).merge(:json_left_overs => unused_data(*params)))
-    end
-
-    def self.cast(value, type, options = {})
-      if options[:none_is_nil] && value == "none"
-        nil
-      # If it's already the correct type then we don't need to do anything
-      elsif value.kind_of?(type)
+    def self.cast(value, type)
+      # If it's already the correct type (or nil) then we don't need to do anything
+      if value.nil? || value.kind_of?(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, options)}
+        value.map {|v| cast(v, type)}
       elsif type == DateTime
         cast_datetime(value)
       elsif type == URI
@@ -250,7 +196,7 @@ module ATDIS
 
     def attribute=(attr, value)
       @attributes_before_type_cast[attr] = value
-      @attributes[attr] = Model.cast(value, attribute_types[attr.to_sym][0], attribute_types[attr.to_sym][1] || {})
+      @attributes[attr] = Model.cast(value, attribute_types[attr.to_sym][0])
     end
 
     def self.cast_datetime(value)
@@ -287,7 +233,7 @@ module ATDIS
       RGeo::GeoJSON.decode(hash_symbols_to_string(value))
     end
 
-    # Converts {:foo => {:bar => "yes"}} to {"foo" => {"bar" => "yes"}}
+    # Converts {foo: {bar: "yes"}} to {"foo" => {"bar" => "yes"}}
     def self.hash_symbols_to_string(hash)
       if hash.respond_to?(:each_pair)
         result = {}