barometer 0.8.0 → 0.9.0

data/spec/data/units_spec.rb

@@ -1,101 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe "Units" do
-
-  describe "when initialized" do
-
-    before(:each) do
-      @units = Data::Units.new
-    end
-
-    it "responds to metric, defaults to true" do
-      @units.metric.should be_true
-    end
-
-    it "allows metric to be set" do
-      @units.metric.should be_true
-
-      @units2 = Data::Units.new(false)
-      @units2.metric.should be_false
-    end
-
-    it "stubs metric_default" do
-      lambda { @units.metric_default = 5 }.should raise_error(NotImplementedError)
-    end
-
-    it "stubs imperial_default" do
-      lambda { @units.imperial_default = 5 }.should raise_error(NotImplementedError)
-    end
-
-  end
-
-  describe "changing units" do
-
-    before(:each) do
-      @units = Data::Units.new
-    end
-
-    it "indicates if metric?" do
-      @units.metric.should be_true
-      @units.metric?.should be_true
-      @units.metric = false
-      @units.metric.should be_false
-      @units.metric?.should be_false
-    end
-
-    it "changes to imperial" do
-      @units.metric?.should be_true
-      @units.imperial!
-      @units.metric?.should be_false
-    end
-
-    it "changes to metric" do
-      @units.metric = false
-      @units.metric?.should be_false
-      @units.metric!
-      @units.metric?.should be_true
-    end
-
-  end
-
-  describe "when assigning values" do
-
-    before(:each) do
-      module Barometer
-        class Data::Units
-          attr_accessor :a, :b
-          def metric_default=(value)
-            self.a = value
-          end
-          def imperial_default=(value)
-            self.b = value
-          end
-        end
-      end
-      @units_metric = Data::Units.new(true)
-      @units_imperial = Data::Units.new(false)
-      @test_value_a = 5.5
-      @test_value_b = 9.9
-    end
-
-    it "assigns metric_default" do
-      @units_metric.metric?.should be_true
-      @units_metric << @test_value_a
-      @units_metric.a.should == @test_value_a
-
-      @units_metric << [@test_value_b, @test_value_a]
-      @units_metric.a.should == @test_value_b
-    end
-
-    it "assigns imperial_default" do
-      @units_imperial.metric?.should be_false
-      @units_imperial << @test_value_a
-      @units_imperial.b.should == @test_value_a
-
-      @units_imperial << [@test_value_a, @test_value_b]
-      @units_imperial.b.should == @test_value_b
-    end
-
-  end
-
-end

data/spec/formats/coordinates_spec.rb

@@ -1,166 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Barometer::Query::Format::Coordinates, :vcr => {
-  :cassette_name => "Query::Format::Coordinates"
-} do
-  before(:each) do
-    @short_zipcode = "90210"
-    @zipcode = @short_zipcode
-    @long_zipcode = "90210-5555"
-    @weather_id = "USGA0028"
-    @postal_code = "T5B 4M9"
-    @coordinates = "40.756054,-73.986951"
-    @geocode = "New York, NY"
-    @icao = "KSFO"
-  end
-
-  describe "and class methods" do
-    it "returns a format" do
-      Barometer::Query::Format::Coordinates.format.should == :coordinates
-    end
-
-    it "returns a country" do
-      Barometer::Query::Format::Coordinates.country_code.should be_nil
-    end
-
-    it "returns a regex" do
-      Barometer::Query::Format::Coordinates.regex.should_not be_nil
-      Barometer::Query::Format::Coordinates.regex.is_a?(Regexp).should be_true
-    end
-
-    it "returns the convertable_formats" do
-      Barometer::Query::Format::Coordinates.convertable_formats.should_not be_nil
-      Barometer::Query::Format::Coordinates.convertable_formats.is_a?(Array).should be_true
-      Barometer::Query::Format::Coordinates.convertable_formats.include?(:short_zipcode).should be_true
-      Barometer::Query::Format::Coordinates.convertable_formats.include?(:zipcode).should be_true
-      Barometer::Query::Format::Coordinates.convertable_formats.include?(:postalcode).should be_true
-      Barometer::Query::Format::Coordinates.convertable_formats.include?(:weather_id).should be_true
-      Barometer::Query::Format::Coordinates.convertable_formats.include?(:coordinates).should be_true
-      Barometer::Query::Format::Coordinates.convertable_formats.include?(:icao).should be_true
-      Barometer::Query::Format::Coordinates.convertable_formats.include?(:geocode).should be_true
-    end
-
-    describe "is?," do
-      before(:each) do
-        @valid = "40.756054,-73.986951"
-        @invalid = "invalid"
-      end
-
-      it "recognizes a valid format" do
-        Barometer::Query::Format::Coordinates.is?(@valid).should be_true
-      end
-
-      it "recognizes non-valid format" do
-        Barometer::Query::Format::Coordinates.is?(@invalid).should be_false
-      end
-    end
-
-    describe "when converting using 'to'," do
-      it "requires a Query::Format object" do
-        lambda { Barometer::Query::Format::Coordinates.to }.should raise_error(ArgumentError)
-        lambda { Barometer::Query::Format::Coordinates.to("invalid") }.should raise_error(ArgumentError)
-        query = Barometer::Query.new(@zipcode)
-        query.is_a?(Barometer::Query).should be_true
-        lambda { Barometer::Query::Format::Coordinates.to(original_query) }.should_not raise_error(ArgumentError)
-      end
-
-      it "returns a Barometer::Query" do
-        query = Barometer::Query.new(@short_zipcode)
-        Barometer::Query::Format::Coordinates.to(query).is_a?(Barometer::Query).should be_true
-      end
-
-      it "converts from short_zipcode" do
-        query = Barometer::Query.new(@short_zipcode)
-        query.format.should == :short_zipcode
-        new_query = Barometer::Query::Format::Coordinates.to(query)
-        new_query.q.should == "34.1030032,-118.4104684"
-        new_query.country_code.should == "US"
-        new_query.format.should == :coordinates
-        new_query.geo.should_not be_nil
-      end
-
-      it "converts from zipcode" do
-        query = Barometer::Query.new(@zipcode)
-        query.format = :zipcode
-        query.format.should == :zipcode
-        new_query = Barometer::Query::Format::Coordinates.to(query)
-        new_query.q.should == "34.1030032,-118.4104684"
-        new_query.country_code.should == "US"
-        new_query.format.should == :coordinates
-        new_query.geo.should_not be_nil
-      end
-
-      it "converts from weather_id" do
-        query = Barometer::Query.new(@weather_id)
-        query.format.should == :weather_id
-        new_query = Barometer::Query::Format::Coordinates.to(query)
-        new_query.q.should == "33.7489954,-84.3879824"
-        new_query.country_code.should == "US"
-        new_query.format.should == :coordinates
-        new_query.geo.should_not be_nil
-      end
-
-      it "converts from geocode" do
-        query = Barometer::Query.new(@geocode)
-        query.format.should == :geocode
-        new_query = Barometer::Query::Format::Coordinates.to(query)
-
-        new_query_coords = new_query.q.split(',').map{|c| c.to_f}
-        new_query_coords[0].should be_within(0.00001).of(40.7143528)
-        new_query_coords[1].should be_within(0.00001).of(-74.0059731)
-
-        new_query.country_code.should == "US"
-        new_query.format.should == :coordinates
-        new_query.geo.should_not be_nil
-      end
-
-      it "converts from postal_code" do
-        query = Barometer::Query.new(@postal_code)
-        query.format.should == :postalcode
-        new_query = Barometer::Query::Format::Coordinates.to(query)
-        new_query.q.should == "53.5721719,-113.4551835"
-        new_query.country_code.should == "CA"
-        new_query.format.should == :coordinates
-        new_query.geo.should_not be_nil
-      end
-
-      it "converts from icao" do
-        query = Barometer::Query.new(@icao)
-        query.format.should == :icao
-        new_query = Barometer::Query::Format::Coordinates.to(query)
-        new_query.q.should == "37.615223,-122.389979"
-        new_query.country_code.should == "US"
-        new_query.format.should == :coordinates
-        new_query.geo.should_not be_nil
-      end
-
-      it "returns nil for other formats" do
-        query = Barometer::Query.new(@coordinates)
-        query.format.should == :coordinates
-        new_query = Barometer::Query::Format::Coordinates.to(query)
-
-        new_query_coords = new_query.q.split(',').map{|c| c.to_f}
-        new_query_coords[0].should be_within(0.00001).of(40.7560413)
-        new_query_coords[1].should be_within(0.00001).of(-73.9869192)
-
-        new_query.country_code.should == "US"
-        new_query.format.should == :coordinates
-        new_query.geo.should_not be_nil
-      end
-    end
-
-    describe "parsing" do
-      it "returns the latitude" do
-        Barometer::Query::Format::Coordinates.parse_latitude(@coordinates).should == "40.756054"
-      end
-
-      it "returns the longitude" do
-        Barometer::Query::Format::Coordinates.parse_longitude(@coordinates).should == "-73.986951"
-      end
-
-      it "returns nil when unknown" do
-        Barometer::Query::Format::Coordinates.parse_longitude(@short_zipcode).should be_nil
-      end
-    end
-  end
-end

data/spec/formats/format_spec.rb

@@ -1,74 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Barometer::Query::Format do
-  describe "and class methods" do
-    describe "is?," do
-      it "requires a String" do
-        invalid = 1
-        lambda { Barometer::Query::Format.is?(invalid) }.should raise_error(ArgumentError)
-
-        valid = "string"
-        valid.is_a?(String).should be_true
-        lambda { Barometer::Query::Format.is?(valid) }.should_not raise_error(ArgumentError)
-      end
-
-      it "calls a stubbed undefined method" do
-        lambda { Barometer::Query::Format.is?("valid") }.should raise_error(NotImplementedError)
-      end
-    end
-
-    describe "converts?," do
-      it "requires a Query object" do
-        invalid = 1
-        Barometer::Query::Format.converts?(invalid).should be_false
-
-        valid = Barometer::Query.new
-        valid.is_a?(Barometer::Query).should be_true
-        lambda { Barometer::Query::Format.converts?(valid) }.should_not raise_error(ArgumentError)
-      end
-
-      it "returns false" do
-        valid = Barometer::Query.new
-        Barometer::Query::Format.converts?(valid).should be_false
-      end
-    end
-
-    it "detects a Query object" do
-      invalid = 1
-      Barometer::Query::Format.is_a_query?.should be_false
-      Barometer::Query::Format.is_a_query?(invalid).should be_false
-      valid = Barometer::Query.new
-      valid.is_a?(Barometer::Query).should be_true
-      Barometer::Query::Format.is_a_query?(valid).should be_true
-    end
-
-    it "stubs regex" do
-      lambda { Barometer::Query::Format.regex }.should raise_error(NotImplementedError)
-    end
-
-    it "stubs format" do
-      lambda { Barometer::Query::Format.format }.should raise_error(NotImplementedError)
-    end
-
-    it "stubs to" do
-      Barometer::Query::Format.to.should be_nil
-    end
-
-    it "stubs country_code" do
-      Barometer::Query::Format.country_code.should be_nil
-    end
-
-    it "stubs convertable_formats" do
-      Barometer::Query::Format.convertable_formats.should == []
-    end
-
-    it "stubs convert_query" do
-      Barometer::Query::Format.respond_to?(:convert_query).should be_true
-    end
-
-    it "normally does nothing when converting a query" do
-      text = "this is a query"
-      Barometer::Query::Format.convert_query(text).should == text
-    end
-  end
-end

data/spec/formats/geocode_spec.rb

@@ -1,163 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Barometer::Query::Format::Geocode, :vcr => {
-  :cassette_name => "Query::Format::Geocode"
-} do
-  before(:each) do
-    @short_zipcode = "90210"
-    @zipcode = @short_zipcode
-    @long_zipcode = "90210-5555"
-    @weather_id = "USGA0028"
-    @postal_code = "T5B 4M9"
-    @coordinates = "40.756054,-73.986951"
-    @geocode = "New York, NY"
-    @icao = "KSFO"
-  end
-
-  describe "and class methods" do
-    it "returns a format" do
-      Barometer::Query::Format::Geocode.format.should == :geocode
-    end
-
-    it "returns a country" do
-      Barometer::Query::Format::Geocode.country_code.should be_nil
-    end
-
-    it "returns the convertable_formats" do
-      Barometer::Query::Format::Geocode.convertable_formats.should_not be_nil
-      Barometer::Query::Format::Geocode.convertable_formats.is_a?(Array).should be_true
-      Barometer::Query::Format::Geocode.convertable_formats.include?(:short_zipcode).should be_true
-      Barometer::Query::Format::Geocode.convertable_formats.include?(:zipcode).should be_true
-      Barometer::Query::Format::Geocode.convertable_formats.include?(:coordinates).should be_true
-      Barometer::Query::Format::Geocode.convertable_formats.include?(:weather_id).should be_true
-      Barometer::Query::Format::Geocode.convertable_formats.include?(:icao).should be_true
-    end
-
-    describe "is?," do
-      before(:each) do
-        @valid = "New York, NY"
-      end
-
-      it "recognizes a valid format" do
-        Barometer::Query::Format::Geocode.is?(@valid).should be_true
-        Barometer::Query::Format::Geocode.is?.should be_false
-      end
-    end
-
-    describe "when converting using 'to'," do
-      before(:each) do
-        Barometer.force_geocode = false
-      end
-
-      it "requires a Barometer::Query object" do
-        lambda { Barometer::Query::Format::Geocode.to }.should raise_error(ArgumentError)
-        lambda { Barometer::Query::Format::Geocode.to("invalid") }.should raise_error(ArgumentError)
-        query = Barometer::Query.new(@zipcode)
-        query.is_a?(Barometer::Query).should be_true
-        lambda { Barometer::Query::Format::Geocode.to(query) }.should_not raise_error(ArgumentError)
-      end
-
-      it "returns a Barometer::Query" do
-        query = Barometer::Query.new(@short_zipcode)
-        Barometer::Query::Format::Geocode.to(query).is_a?(Barometer::Query).should be_true
-      end
-
-      it "converts from short_zipcode" do
-        query = Barometer::Query.new(@short_zipcode)
-        query.format.should == :short_zipcode
-        new_query = Barometer::Query::Format::Geocode.to(query)
-        new_query.q.should == "Beverly Hills, CA, United States"
-        new_query.country_code.should == "US"
-        new_query.format.should == :geocode
-        new_query.geo.should_not be_nil
-      end
-
-      it "converts from zipcode" do
-        query = Barometer::Query.new(@zipcode)
-        query.format = :zipcode
-        query.format.should == :zipcode
-        new_query = Barometer::Query::Format::Geocode.to(query)
-        new_query.q.should == "Beverly Hills, CA, United States"
-        new_query.country_code.should == "US"
-        new_query.format.should == :geocode
-        new_query.geo.should_not be_nil
-      end
-
-      it "converts from weather_id" do
-        query = Barometer::Query.new(@weather_id)
-        query.format.should == :weather_id
-        new_query = Barometer::Query::Format::Geocode.to(query)
-        new_query.q.should == "Atlanta, GA, US"
-        new_query.country_code.should be_nil
-        new_query.format.should == :geocode
-        new_query.geo.should be_nil
-      end
-
-      it "converts from coordinates" do
-        query = Barometer::Query.new(@coordinates)
-        query.format.should == :coordinates
-        new_query = Barometer::Query::Format::Geocode.to(query)
-        new_query.q.should == "Manhattan, NY, United States"
-        new_query.country_code.should == "US"
-        new_query.format.should == :geocode
-        new_query.geo.should_not be_nil
-      end
-
-      it "converts from icao" do
-        query = Barometer::Query.new(@icao)
-        query.format.should == :icao
-        new_query = Barometer::Query::Format::Geocode.to(query)
-        new_query.q.should == "San Francisco, CA, United States"
-        new_query.country_code.should == "US"
-        new_query.format.should == :geocode
-        new_query.geo.should_not be_nil
-      end
-
-      it "does not convert postalcode" do
-        query = Barometer::Query.new(@postal_code)
-        query.format.should == :postalcode
-        new_query = Barometer::Query::Format::Geocode.to(query)
-        new_query.should be_nil
-      end
-
-      it "leaves geocode untouched" do
-        query = Barometer::Query.new(@geocode)
-        query.format.should == :geocode
-        new_query = Barometer::Query::Format::Geocode.to(query)
-        new_query.q.should == "New York, NY"
-        new_query.country_code.should be_nil
-        new_query.format.should == :geocode
-        new_query.geo.should be_nil
-      end
-    end
-
-    describe "when geocoding" do
-      it "requires a Barometer::Query object" do
-        lambda { Barometer::Query::Format::Geocode.geocode }.should raise_error(ArgumentError)
-        lambda { Barometer::Query::Format::Geocode.geocode("invalid") }.should raise_error(ArgumentError)
-        query = Barometer::Query.new(@zipcode)
-        query.is_a?(Barometer::Query).should be_true
-        lambda { Barometer::Query::Format::Geocode.geocode(original_query) }.should_not raise_error(ArgumentError)
-      end
-
-      it "returns a Barometer::Query" do
-        query = Barometer::Query.new(@short_zipcode)
-        Barometer::Query::Format::Geocode.geocode(query).is_a?(Barometer::Query).should be_true
-      end
-
-      it "converts from short_zipcode" do
-        query = Barometer::Query.new(@short_zipcode)
-        query.format.should == :short_zipcode
-        new_query = Barometer::Query::Format::Geocode.geocode(query)
-        new_query.q.should == "Beverly Hills, CA, United States"
-        new_query.country_code.should == "US"
-        new_query.format.should == :geocode
-        new_query.geo.should_not be_nil
-      end
-    end
-
-    it "doesn't define a regex" do
-      lambda { Barometer::Query::Format::Geocode.regex }.should raise_error(NotImplementedError)
-    end
-  end
-end