atdis 0.1

data/lib/atdis/version.rb

@@ -0,0 +1,3 @@
+module Atdis
+  VERSION = "0.1"
+end

data/lib/atdis.rb

@@ -0,0 +1,12 @@
+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"

data/spec/atdis/application_spec.rb

@@ -0,0 +1,406 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe ATDIS::Application do
+
+  context "extra parameter in json" do
+    it "should not be valid" do
+      ATDIS::Location.should_receive(:interpret).with(:foo => "Some location data").and_return(double(:valid? => true))
+      a = ATDIS::Application.interpret(:application => {
+        :info => {
+          :dat_id => "DA2013-0381",
+          :last_modified_date => "2013-04-20T02:01:07Z",
+          :description => "New pool plus deck",
+          :authority => "Example Council Shire Council",
+          :lodgement_date => "2013-04-20T02:01:07Z",
+          :determination_date => "2013-06-20",
+          :status => "OPEN"
+        },
+        :reference => {
+          # This is the extra parameter that shouldn't be here
+          :foo => "bar",
+          :more_info_url => "http://foo.com/bar"
+        },
+        :location => {:foo => "Some location data"}
+      })
+      a.should_not be_valid
+      a.errors.messages.should == {:json => ['Unexpected parameters in json data: {"application":{"reference":{"foo":"bar"}}}']}
+    end
+  end
+
+  describe ".interpret" do
+    it "should parse the json and create an application object" do
+      application = double
+
+      ATDIS::Application.should_receive(:new).with(
+        :dat_id => "DA2013-0381",
+        :last_modified_date => "2013-04-20T02:01:07Z",
+        :description => "New pool plus deck",
+        :authority => "Example Council Shire Council",
+        :lodgement_date => "2013-04-20T02:01:07Z",
+        :determination_date => "2013-06-20",
+        :notification_start_date => "2013-04-20T02:01:07Z",
+        :notification_end_date => "2013-05-20T02:01:07Z",
+        :officer => "Ms Smith",
+        :estimated_cost => "50,000",
+        :status => "OPEN",
+        :more_info_url => "http://foo.com/bar",
+        :comments_url => "http://foo.com/comment",
+        :location => { :address => "123 Fourfivesix Street" },
+        :events => [ { :id => "event1" }, { :id => "event2" } ],
+        :documents => [ { :ref => "27B/6/a" }, { :ref => "27B/6/b" } ],
+        :people => [ { :name => "Tuttle" }, { :name => "Buttle" } ],
+        :extended => {:another_parameter => "with some value", :anything => "can go here"},
+        :json_left_overs => {}
+      ).and_return(application)
+
+      ATDIS::Application.interpret(:application => {
+        :info => {
+          :dat_id => "DA2013-0381",
+          :last_modified_date => "2013-04-20T02:01:07Z",
+          :description => "New pool plus deck",
+          :authority => "Example Council Shire Council",
+          :lodgement_date => "2013-04-20T02:01:07Z",
+          :determination_date => "2013-06-20",
+          :notification_start_date => "2013-04-20T02:01:07Z",
+          :notification_end_date => "2013-05-20T02:01:07Z",
+          :officer => "Ms Smith",
+          # TODO: In ATDIS-1.0.3 it does not specify whether this is a float or a string
+          # and whether to include (or not) AUD or dollar sign. For the time being we'll
+          # just assume it's a free-form string
+          :estimated_cost => "50,000",
+          :status => "OPEN"
+        },
+        :reference => {
+          :more_info_url => "http://foo.com/bar",
+          :comments_url => "http://foo.com/comment"
+        },
+        :location => { :address => "123 Fourfivesix Street" },
+        :events => [ { :id => "event1" }, { :id => "event2" } ],
+        :documents => [ { :ref => "27B/6/a" }, { :ref => "27B/6/b" } ],
+        :people => [ { :name => "Tuttle" }, { :name => "Buttle" } ],
+        :extended => {:another_parameter => "with some value", :anything => "can go here"}
+      }).should == application
+    end
+
+    it "should create a nil valued application when there is no information in the json" do
+      application = double
+      ATDIS::Application.should_receive(:new).with({:json_left_overs => {}}).and_return(application)
+
+      ATDIS::Application.interpret(:application => {:info => {}, :reference => {}}).should == application
+    end
+  end
+
+  describe "#extended" do
+    it "should do no typecasting" do
+      a = ATDIS::Application.new(:extended => {:another_parameter => "with some value", :anything => "can go here"})
+      a.extended.should == {:another_parameter => "with some value", :anything => "can go here"}
+    end
+  end
+
+  describe "#location=" do
+    let(:a) { ATDIS::Application.new }
+    it "should type cast to a location" do
+      location = double
+      ATDIS::Location.should_receive(:interpret).with(:address => "123 Fourfivesix Street").and_return(location)
+      a.location = { :address => "123 Fourfivesix Street" }
+      a.location.should == location
+    end
+
+    it "should not cast when it's already a location" do
+      l = ATDIS::Location.new
+      a.location = l
+      a.location.should == l
+    end
+  end
+
+  describe "#events" do
+    let(:a) { ATDIS::Application.new }
+    it "should type cast to several events" do
+      event1, event2 = double, double
+      ATDIS::Event.should_receive(:interpret).with(:id => "event1").and_return(event1)
+      ATDIS::Event.should_receive(:interpret).with(:id => "event2").and_return(event2)
+      a.events = [ { :id => "event1" }, { :id => "event2" } ]
+      a.events.should == [event1, event2]
+    end
+  end
+
+  describe "#documents" do
+    let(:a) { ATDIS::Application.new }
+    it "should type cast to several documents" do
+      document1, document2 = double, double
+      ATDIS::Document.should_receive(:interpret).with(:ref => "27B/6/a").and_return(document1)
+      ATDIS::Document.should_receive(:interpret).with(:ref => "27B/6/b").and_return(document2)
+      a.documents = [ { :ref => "27B/6/a" }, { :ref => "27B/6/b" } ]
+      a.documents.should == [document1, document2]
+    end
+  end
+
+  describe "#people" do
+    let(:a) { ATDIS::Application.new }
+    it "should type cast to several people" do
+      tuttle, buttle = double, double
+      ATDIS::Person.should_receive(:interpret).with(:name => "Tuttle").and_return(tuttle)
+      ATDIS::Person.should_receive(:interpret).with(:name => "Buttle").and_return(buttle)
+      a.people = [ { :name => "Tuttle" }, { :name => "Buttle" } ]
+      a.people.should == [tuttle, buttle]
+    end
+  end
+
+  describe "#last_modified_date=" do
+    let(:a) { ATDIS::Application.new }
+    it "should do no type casting when it's already a date" do
+      a.last_modified_date = DateTime.new(2013,1,1)
+      a.last_modified_date.should == DateTime.new(2013,1,1)
+    end
+
+    it "should cast a string to a date when it's a valid date" do
+      a.last_modified_date = "2013-01-01"
+      a.last_modified_date.should == DateTime.new(2013,1,1)
+    end
+
+    context "not a valid date" do
+      before :each do
+        a.last_modified_date = "2013/01/01"
+      end
+      it "should be nil" do
+        a.last_modified_date.should be_nil
+      end
+      it "should keep the original string" do
+        a.last_modified_date_before_type_cast.should == "2013/01/01"
+      end
+    end
+  end
+
+  describe "#lodgement_date=" do
+    let(:a) { ATDIS::Application.new }
+    it "should do no type casting when it's already a date" do
+      a.lodgement_date = DateTime.new(2013,1,1)
+      a.lodgement_date.should == DateTime.new(2013,1,1)
+    end
+
+    it "should cast a string to a date when it's a valid date" do
+      a.lodgement_date = "2013-01-01"
+      a.lodgement_date.should == DateTime.new(2013,1,1)
+    end
+
+    context "not a valid date" do
+      before :each do
+        a.lodgement_date = "2013/01/01"
+      end
+      it "should be nil" do
+        a.lodgement_date.should be_nil
+      end
+      it "should keep the original string" do
+        a.lodgement_date_before_type_cast.should == "2013/01/01"
+      end
+    end
+  end
+
+  describe "#more_info_url=" do
+    let(:a) { ATDIS::Application.new }
+    it "should do no type casting when it's already a URI" do
+      a.more_info_url = URI.parse("http://foo.com/bar")
+      a.more_info_url.should == URI.parse("http://foo.com/bar")
+    end
+
+    it "should cast a string to a URI when it's a valid url" do
+      a.more_info_url = "http://foo.com/bar"
+      a.more_info_url.should == URI.parse("http://foo.com/bar")
+    end
+
+    context "not a valid url" do
+      before :each do
+        a.more_info_url = "This is not a url"
+      end
+      it "should be nil" do      
+        a.more_info_url.should be_nil
+      end
+      it "should keep the original string" do
+        a.more_info_url_before_type_cast.should == "This is not a url"
+      end
+    end
+  end
+
+  describe "#description=" do
+    let(:a) { ATDIS::Application.new }
+    it "should do not type casting when it's already a String" do
+      a.description = "foo"
+      a.description.should == "foo"
+    end
+    context "not a string" do
+      before :each do
+        a.description = 123
+      end
+      it "should cast to a string when it's not a string" do
+        a.description.should == "123"
+      end
+      it "should keep the original value" do
+        a.description_before_type_cast.should == 123
+      end
+    end
+  end
+
+  # TODO This should really be a test on the Model base class
+  describe ".attributes" do
+    it do
+      a = ATDIS::Application.new(:dat_id => "DA2013-0381", :description => "New pool plus deck")
+      a.attributes.should == {"dat_id" => "DA2013-0381", "description" => "New pool plus deck"}
+    end
+  end
+
+  # TODO This should really be a test on the Model base class
+  describe "#attribute_names" do
+    it do
+      ATDIS::Application.attribute_names.sort.should == ["authority", "comments_url", "dat_id", "description",
+        "determination_date", "documents", "estimated_cost", "events", "extended", "last_modified_date",
+        "location", "lodgement_date", "more_info_url", "notification_end_date", "notification_start_date", "officer",
+        "people", "status"]
+    end
+  end
+
+  describe "validations" do
+    before :each do
+      l = double(:valid? => true)
+      ATDIS::Location.should_receive(:interpret).with(:address => "123 Fourfivesix Street Neutral Bay NSW 2089").and_return(l)
+    end
+
+    let(:a) { ATDIS::Application.new(
+      :dat_id => "DA2013-0381",
+      :last_modified_date => DateTime.new(2013,4,20,2,1,7),
+      :description => "New pool plus deck",
+      :authority => "Example Council Shire Council",
+      :lodgement_date => DateTime.new(2013,4,20,2,1,7),
+      :determination_date => DateTime.new(2013,6,20),  
+      :status => "OPEN",
+      :more_info_url => URI.parse("http://foo.com/bar"),
+      :location => {:address => "123 Fourfivesix Street Neutral Bay NSW 2089"}
+  ) }
+
+    it { a.should be_valid }
+
+    describe ".location" do
+      it "should not be valid if the location is not valid" do
+        l = double(:valid? => false)
+        ATDIS::Location.should_receive(:interpret).with(:foo => "some location data").and_return(l)
+        a.location = {:foo => "some location data"}
+        a.should_not be_valid
+      end
+    end
+
+    it ".dat_id" do
+      a.dat_id = nil
+      a.should_not be_valid
+      a.errors.messages.should == {:dat_id => ["can't be blank"]}
+    end
+
+    describe ".last_modified_date" do
+      it do
+        a.last_modified_date = nil
+        a.should_not be_valid
+        a.errors.messages.should == {:last_modified_date => ["can't be blank"]}
+      end
+      it do
+        a.last_modified_date = "18 January 2013"
+        a.should_not be_valid
+        a.errors.messages.should == {:last_modified_date => ["is not a valid date"]}
+      end
+    end
+
+    describe ".description" do
+      it do
+        a.description = ""
+        a.should_not be_valid
+        a.errors.messages.should == {:description => ["can't be blank"]}
+      end
+    end
+
+    describe ".authority" do
+      it do
+        a.authority = nil
+        a.should_not be_valid
+        a.errors.messages.should == {:authority => ["can't be blank"]}
+      end
+    end
+
+    describe ".lodgement_date" do
+      it do
+        a.lodgement_date = nil
+        a.should_not be_valid
+        a.errors.messages.should == {:lodgement_date => ["can't be blank"]}
+      end
+      it do
+        a.lodgement_date = "18 January 2013"
+        a.should_not be_valid
+        a.errors.messages.should == {:lodgement_date => ["is not a valid date"]}
+      end
+    end
+
+    describe ".determination_date" do
+      it do
+        a.determination_date = nil
+        a.should_not be_valid
+        a.errors.messages.should == {:determination_date => ["can't be blank"]}
+      end
+      it do
+        a.determination_date = "18 January 2013"
+        a.should_not be_valid
+        a.errors.messages.should == {:determination_date => ["is not a valid date"]}
+      end
+    end
+
+    describe ".status" do
+      it do
+        a.status = nil
+        a.should_not be_valid
+        a.errors.messages.should == {:status => ["can't be blank"]}
+      end
+    end
+
+    describe ".notification_start_date" do
+      it do
+        a.notification_start_date = DateTime.new(2013,4,20,2,1,7)
+        a.should be_valid
+      end
+      it do
+        a.notification_start_date = "18 January 2013"
+        a.should_not be_valid
+        a.errors.messages.should == {:notification_start_date => ["is not a valid date"]}
+      end
+    end
+
+    describe ".notification_end_date" do
+      it do
+        a.notification_end_date = DateTime.new(2013,5,20,2,1,7)
+        a.should be_valid
+      end
+      it do
+        a.notification_end_date = "18 January 2013"
+        a.should_not be_valid
+        a.errors.messages.should == {:notification_end_date => ["is not a valid date"]}
+      end
+    end
+
+    describe ".more_info_url" do
+      it do
+        a.more_info_url = nil
+        a.should_not be_valid
+        a.errors.messages.should == {:more_info_url => ["can't be blank"]}
+      end
+      it do
+        a.more_info_url = "This is not a valid url"
+        a.should_not be_valid
+        a.errors.messages.should == {:more_info_url => ["is not a valid URL"]}
+      end
+      it do
+        a.more_info_url = "foo.com"
+        a.should_not be_valid
+        a.errors.messages.should == {:more_info_url => ["is not a valid URL"]}
+      end
+      it do
+        a.more_info_url = "httpss://foo.com"
+        a.should_not be_valid
+        a.errors.messages.should == {:more_info_url => ["is not a valid URL"]}
+      end
+    end
+  end
+end

data/spec/atdis/document_spec.rb

@@ -0,0 +1,15 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe ATDIS::Document do
+  it ".ref" do
+    ATDIS::Document.interpret(:ref => "27B/6").ref.should == "27B/6"
+  end
+
+  it ".title" do
+    ATDIS::Document.interpret(:title => "Authorisation for Repairs").title.should == "Authorisation for Repairs"
+  end
+
+  it ".document_url" do
+    ATDIS::Document.interpret(:document_url => "http://foo.com/bar").document_url.should == URI.parse("http://foo.com/bar")
+  end
+end

data/spec/atdis/event_spec.rb

@@ -0,0 +1,25 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe ATDIS::Event do
+  it ".id" do
+    ATDIS::Event.interpret(:id => "27B/6").id.should == "27B/6"
+  end
+
+  it ".date" do
+    ATDIS::Event.interpret(:date => "2013-06-18").date.should == DateTime.new(2013,6,18)
+  end
+
+  it ".description" do
+    ATDIS::Event.interpret(:description => "A very fine event").description.should == "A very fine event"
+  end
+
+  it ".event_type" do
+    # TODO Is event_type always a string? ATDIS-1.0.3 doesn't say
+    ATDIS::Event.interpret(:event_type => "approval").event_type.should == "approval"
+  end
+
+  it ".status" do
+    # TODO Is status always a string? ATDIS-1.0.3 doesn't say
+    ATDIS::Event.interpret(:status => "approved").status.should == "approved"
+  end
+end

data/spec/atdis/feed_spec.rb

@@ -0,0 +1,40 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe ATDIS::Feed do
+  let (:base_url_string) { "http://www.council.nsw.gov.au" }
+  let (:base_url) { URI.parse(base_url_string) }
+
+  context "base_url passed as string" do
+    let(:feed) { ATDIS::Feed.new(base_url_string) }
+
+    describe "#base_url" do
+      it { feed.base_url.should == base_url }
+    end
+
+    describe "#applications" do
+      it do
+        applications_results = double
+        ATDIS::Page.should_receive(:read_url).with(URI.parse("http://www.council.nsw.gov.au/atdis/1.0/applications.json")).and_return(applications_results)
+        feed.applications.should == applications_results
+      end
+    end
+  end
+
+  context "base_url passed as url" do
+    let(:feed) { ATDIS::Feed.new(base_url) }
+
+    describe "#base_url" do
+      it { feed.base_url.should == base_url }
+    end
+  end
+
+  context "request for page 2" do
+    let(:feed) { ATDIS::Feed.new(base_url_string)}
+
+    it "#applications" do
+        applications_results = double
+        ATDIS::Page.should_receive(:read_url).with(URI.parse("http://www.council.nsw.gov.au/atdis/1.0/applications.json?page=2")).and_return(applications_results)
+        feed.applications(2).should == applications_results
+    end
+  end
+end

data/spec/atdis/location_spec.rb

@@ -0,0 +1,97 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe ATDIS::Location do
+  describe "validation" do
+    context "valid location" do
+      let(:l) { ATDIS::Location.new(
+        :address => "123 Fourfivesix Street Neutral Bay NSW 2089",
+        :lot => "10",
+        :section => "ABC",
+        :dpsp_id => "DP2013-0381",
+        :geometry => {
+          :type => "Point",
+          :coordinates => [100.0, 0.0]
+        }
+      )}
+      
+      it { l.should be_valid }
+
+      it "address" do
+        l.address = ""
+        l.should_not be_valid
+        l.errors.messages.should == {:address => ["can't be blank"]}
+      end
+
+      it "geometry" do
+        l.geometry = {:type => "Point"}
+        l.geometry.should be_nil
+        l.should_not be_valid
+      end
+    end
+  end
+
+  describe ".interpret" do
+    it "should interpret a parsed json block of location data" do
+      l = ATDIS::Location.interpret(
+        :address => "123 Fourfivesix Street Neutral Bay NSW 2089",
+        :land_title_ref => {
+          :lot => "10",
+          :section => "ABC",
+          :dpsp_id => "DP2013-0381"
+        })
+      
+      l.address.should == "123 Fourfivesix Street Neutral Bay NSW 2089"
+      l.lot.should == "10"
+      l.section.should == "ABC"
+      l.dpsp_id.should == "DP2013-0381"
+    end
+
+    it "should gracefully handle the land_title_ref block being missing" do
+      l = ATDIS::Location.interpret(:address => "123 Fourfivesix Street Neutral Bay NSW 2089")
+      
+      l.address.should == "123 Fourfivesix Street Neutral Bay NSW 2089"
+      l.lot.should be_nil
+      l.section.should be_nil
+      l.dpsp_id.should be_nil
+    end
+
+    it "should pass on the responsibility for parsing the geometry section" do
+      # TODO Not 100% clear from section 4.3.3 of ATDIS-1.0.3 if this is the correct indentation
+      l = ATDIS::Location.interpret(
+        :geometry => {
+          :type => "Point",
+          :coordinates => [100.0, 0.0]
+        }
+      )
+      # TODO Check that the returned geometry is a point
+      l.geometry.x.should == 100
+      l.geometry.y.should == 0
+    end
+
+    it "should interpret a polygon in the geometry section" do
+      # TODO Not 100% clear from section 4.3.3 of ATDIS-1.0.3 if this is the correct indentation
+      l = ATDIS::Location.interpret(
+        :geometry => {
+          :type => "Polygon",
+          :coordinates => [
+            [ [100.0, 0.0], [101.0, 0.0], [101.0, 1.0],
+              [100.0, 1.0], [100.0, 0.0] ]
+          ]
+        }
+      )
+      # TODO Check that the returned geometry is a polygon
+      l.geometry.interior_rings.should be_empty
+      l.geometry.exterior_ring.points.count.should == 5
+      l.geometry.exterior_ring.points[0].x.should == 100
+      l.geometry.exterior_ring.points[0].y.should == 0
+      l.geometry.exterior_ring.points[1].x.should == 101
+      l.geometry.exterior_ring.points[1].y.should == 0
+      l.geometry.exterior_ring.points[2].x.should == 101
+      l.geometry.exterior_ring.points[2].y.should == 1
+      l.geometry.exterior_ring.points[3].x.should == 100
+      l.geometry.exterior_ring.points[3].y.should == 1
+      l.geometry.exterior_ring.points[4].x.should == 100
+      l.geometry.exterior_ring.points[4].y.should == 0
+    end
+  end
+end

data/spec/atdis/model_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe ATDIS::Model do
+  describe ".cast" do 
+    it {ATDIS::Model.cast("2013-04-20T02:01:07Z", DateTime).should == DateTime.new(2013,4,20,2,1,7)}
+    it {ATDIS::Model.cast("2013-04-20", DateTime).should == DateTime.new(2013,4,20)}
+    it {ATDIS::Model.cast("2013-04-20T02:01:07+05:00", DateTime).should == DateTime.new(2013,4,20,2,1,7,"+5")}
+    it {ATDIS::Model.cast("2013-04-20T02:01:07-05:00", DateTime).should == DateTime.new(2013,4,20,2,1,7,"-5")}
+    it {ATDIS::Model.cast("2013-04", DateTime).should be_nil}
+    it {ATDIS::Model.cast("18 September 2013", DateTime).should be_nil}
+    it {ATDIS::Model.cast(DateTime.new(2013,4,20,2,1,7), DateTime).should == DateTime.new(2013,4,20,2,1,7)}
+
+    it "should cast arrays by casting each member" do
+      ATDIS::Model.cast([1, 2, 3], String).should == ["1", "2", "3"]
+    end
+
+    # This casting allows nil values
+    describe "casting Fixnum" do
+      it { ATDIS::Model.cast("3", Fixnum).should == 3}
+      it { ATDIS::Model.cast("4.0", Fixnum).should == 4}
+      it { ATDIS::Model.cast(5, Fixnum).should == 5}
+      it { ATDIS::Model.cast(0, Fixnum).should == 0}
+      it { ATDIS::Model.cast(nil, Fixnum).should be_nil}
+    end
+  end
+
+  describe ".map_fields" do
+    it do
+      ATDIS::Model.map_fields({:foo => :bar, :a => :b}, {:foo => 2, :a => 3, :d => 4}).should ==
+        {:bar => 2, :b => 3, :json_left_overs => {:d => 4}}
+    end
+
+    it do
+      ATDIS::Model.map_fields({:foo => :bar, :a => :b, :info => {:foo => :bar2, :a => :b2}},
+        {:foo => 2, :a => 3, :d => 4, :info => {:foo => 2, :a => 3, :d => 4}}).should ==
+        {:bar => 2, :b => 3, :bar2 => 2, :b2 => 3, :json_left_overs => {:d => 4, :info => {:d => 4}}}
+    end
+  end
+end