barometer 0.3.2 → 0.5.0

data/lib/barometer/formats/zipcode.rb

@@ -0,0 +1,31 @@
+module Barometer
+  #
+  # Format: Zip Code
+  #
+  # eg. 90210 or 90210-5555
+  #
+  # This class is used to determine if a query is a
+  # :zip_code, how to convert to a :zip_code
+  # and what the country_code is.
+  #
+  class Query::Format::Zipcode < Query::Format
+  
+    def self.format; :zipcode; end
+    def self.country_code(query=nil); "US"; end
+    def self.regex; /(^[0-9]{5}$)|(^[0-9]{5}-[0-9]{4}$)/; end
+    def self.convertable_formats; [:short_zipcode]; end
+
+    # convert to this format, X -> :zipcode
+    #
+    def self.to(original_query)
+      raise ArgumentError unless is_a_query?(original_query)
+      return nil unless converts?(original_query)
+      converted_query = Barometer::Query.new
+      converted_query.q = original_query.q
+      converted_query.format = format
+      converted_query.country_code = country_code(converted_query.q)
+      converted_query
+    end
+  
+  end
+end

data/lib/barometer/query.rb

@@ -12,266 +12,95 @@ module Barometer
   #   certain formats, and only permit certain formats.  The Query class
   #   will attempt to either return the query string as-is if acceptable,
   #   or it will attempt to convert it to a format that is acceptable
-  #   (most likely this conversion will in Googles geocoding service using
+  #   (most likely this conversion will use Googles geocoding service using
   #   the Graticule gem).  Worst case scenario is that the Weather API will
   #   not accept the query string.
   #
   class Query
     
-    # OPTIONAL: key required by Google for geocoding
-    @@google_geocode_key = nil
-    def self.google_geocode_key; @@google_geocode_key || Barometer.google_geocode_key; end;
-    def self.google_geocode_key=(key); @@google_geocode_key = key; end;
-    
-    attr_reader   :format
-    attr_accessor :q, :preferred, :country_code, :geo
+    # This array defines the order to check a query for the format
+    #
+    FORMATS = %w(
+      ShortZipcode Zipcode Postalcode WeatherID Coordinates Icao Geocode
+    )
+    FORMAT_MAP = {
+      :short_zipcode => "ShortZipcode", :zipcode => "Zipcode",
+      :postalcode => "Postalcode", :weather_id => "WeatherID",
+      :coordinates => "Coordinates", :icao => "Icao",
+      :geocode => "Geocode"
+    }
+    
+    attr_accessor :format, :q, :country_code, :geo
     
     def initialize(query=nil)
+      return unless query
       @q = query
       self.analyze!
     end
-    
+
     # analyze the saved query to determine the format.
+    # this delegates the detection to each formats class
+    # until th right one is found
+    #
     def analyze!
       return unless @q
-      if Barometer::Query.is_us_zipcode?(@q)
-        @format = :zipcode
-        @country_code = Barometer::Query.format_to_country_code(@format)
-      elsif Barometer::Query.is_canadian_postcode?(@q)
-        @format = :postalcode
-        @country_code = Barometer::Query.format_to_country_code(@format)
-      elsif Barometer::Query.is_coordinates?(@q)
-        @format = :coordinates
-      elsif Barometer::Query.is_icao?(@q)
-        @format = :icao
-#        @country_code = Barometer::Query.icao_to_country_code(@q)
-      else
-        @format = :geocode
+      FORMATS.each do |format|
+        if Query::Format.const_get(format.to_s).is?(@q)
+          @format = Query::Format.const_get(format.to_s).format
+          @country_code = Query::Format.const_get(format.to_s).country_code(@q)
+          break
+        end
       end
     end
     
     # take a list of acceptable (and ordered by preference) formats and convert
-    # the current query (q) into the most preferred and acceptable format. as a
-    # side effect of some conversions, the country_code might be known, then save it
+    # the current query (q) into the most preferred and acceptable format. a
+    # side effect of the conversions may reveal the country_code, if so save it
+    #
     def convert!(preferred_formats=nil)
       raise ArgumentError unless (preferred_formats && preferred_formats.size > 0)
-      # reset preferred
-      @preferred = nil
       
-      # go through each acceptable format and try to convert to that
-      converted = false
-      geocoded = false
-      preferred_formats.each do |preferred_format|
-        # we are already in this format, return this
-        if preferred_format == @format
-          converted = true
-          @preferred ||= @q
-        end
-        
-        unless converted
-          case preferred_format
-          when :coordinates
-            geocoded = true
-            @preferred, @country_code, @geo = Barometer::Query.to_coordinates(@q, @format)
-          when :geocode
-            geocoded = true
-            @preferred, @country_code, @geo = Barometer::Query.to_geocode(@q, @format)
-          end
-        end
+      # why convert if we are already there?
+      skip_conversion = false
+      if preferred_formats.include?(@format.to_sym)
+        skip_conversion = true
+        converted_query = self.dup
       end
       
-      # if we haven't already geocoded and we are forcing it, do it now
-      if !geocoded && Barometer.force_geocode
-        not_used_coords, not_used_code, @geo = Barometer::Query.to_coordinates(@q, @format)
+      unless skip_conversion
+        # go through each acceptable format and try to convert to that
+        converted = false
+        converted_query = Barometer::Query.new
+        preferred_formats.each do |preferred_format|
+          klass = FORMAT_MAP[preferred_format.to_sym]
+          if preferred_format == @format
+            converted = true
+            converted_query = Barometer::Query.new(@q)
+          end
+          unless converted
+            converted_query =  Query::Format.const_get(klass.to_s).to(self)
+            converted = true if converted_query
+          end
+          if converted
+            converted_query.country_code ||= Query::Format.const_get(klass.to_s).country_code(converted_query.q)
+            break
+          end
+        end
       end
       
-      @preferred
-    end
-    
-    #
-    # HELPERS
-    #
-    
-    def zipcode?; @format == :zipcode; end
-    def postalcode?; @format == :postalcode; end
-    def coordinates?; @format == :coordinates; end
-    def geocode?; @format == :geocode; end
-    def icao?; @format == :icao; end
-    
-    def self.is_us_zipcode?(query)
-      us_zipcode_regex = /(^[0-9]{5}$)|(^[0-9]{5}-[0-9]{4}$)/
-      return !(query =~ us_zipcode_regex).nil?
-    end
-    
-    def self.is_canadian_postcode?(query)
-      # Rules: no D, F, I, O, Q, or U anywhere
-      # Basic validation: ^[ABCEGHJ-NPRSTVXY]{1}[0-9]{1}[ABCEGHJ-NPRSTV-Z]{1}[ ]?[0-9]{1}[ABCEGHJ-NPRSTV-Z]{1}[0-9]{1}$
-      # Extended validation: ^(A(0[ABCEGHJ-NPR]|1[ABCEGHK-NSV-Y]|2[ABHNV]|5[A]|8[A])|B(0[CEHJ-NPRSTVW]|1[ABCEGHJ-NPRSTV-Y]|2[ABCEGHJNRSTV-Z]|3[ABEGHJ-NPRSTVZ]|4[ABCEGHNPRV]|5[A]|6[L]|9[A])|C(0[AB]|1[ABCEN])|E(1[ABCEGHJNVWX]|2[AEGHJ-NPRSV]|3[ABCELNVYZ]|4[ABCEGHJ-NPRSTV-Z]|5[ABCEGHJ-NPRSTV]|6[ABCEGHJKL]|7[ABCEGHJ-NP]|8[ABCEGJ-NPRST]|9[ABCEGH])|G(0[ACEGHJ-NPRSTV-Z]|1[ABCEGHJ-NPRSTV-Y]|2[ABCEGJ-N]|3[ABCEGHJ-NZ]|4[ARSTVWXZ]|5[ABCHJLMNRTVXYZ]|6[ABCEGHJKLPRSTVWXZ]|7[ABGHJKNPSTXYZ]|8[ABCEGHJ-NPTVWYZ]|9[ABCHNPRTX])|H(0[HM]|1[ABCEGHJ-NPRSTV-Z]|2[ABCEGHJ-NPRSTV-Z]|3[ABCEGHJ-NPRSTV-Z]|4[ABCEGHJ-NPRSTV-Z]|5[AB]|7[ABCEGHJ-NPRSTV-Y]|8[NPRSTYZ]|9[ABCEGHJKPRSWX])|J(0[ABCEGHJ-NPRSTV-Z]|1[ACEGHJ-NRSTXZ]|2[ABCEGHJ-NRSTWXY]|3[ABEGHLMNPRTVXYZ]|4[BGHJ-NPRSTV-Z]|5[ABCJ-MRTV-Z]|6[AEJKNRSTVWYXZ]|7[ABCEGHJ-NPRTV-Z]|8[ABCEGHLMNPRTVXYZ]|9[ABEHJLNTVXYZ])|K(0[ABCEGHJ-M]|1[ABCEGHJ-NPRSTV-Z]|2[ABCEGHJ-MPRSTVW]|4[ABCKMPR]|6[AHJKTV]|7[ACGHK-NPRSV]|8[ABHNPRV]|9[AHJKLV])|L(0[[ABCEGHJ-NPRS]]|1[ABCEGHJ-NPRSTV-Z]|2[AEGHJMNPRSTVW]|3[BCKMPRSTVXYZ]|4[ABCEGHJ-NPRSTV-Z]|5[ABCEGHJ-NPRSTVW]|6[ABCEGHJ-MPRSTV-Z]|7[ABCEGJ-NPRST]|8[EGHJ-NPRSTVW]|9[ABCGHK-NPRSTVWYZ])|M(1[BCEGHJ-NPRSTVWX]|2[HJ-NPR]|3[ABCHJ-N]|4[ABCEGHJ-NPRSTV-Y]|5[ABCEGHJ-NPRSTVWX]|6[ABCEGHJ-NPRS]|7[AY]|8[V-Z]|9[ABCLMNPRVW])|N(0[ABCEGHJ-NPR]|1[ACEGHKLMPRST]|2[ABCEGHJ-NPRTVZ]|3[ABCEHLPRSTVWY]|4[BGKLNSTVWXZ]|5[ACHLPRV-Z]|6[ABCEGHJ-NP]|7[AGLMSTVWX]|8[AHMNPRSTV-Y]|9[ABCEGHJKVY])|P(0[ABCEGHJ-NPRSTV-Y]|1[ABCHLP]|2[ABN]|3[ABCEGLNPY]|4[NPR]|5[AEN]|6[ABC]|7[ABCEGJKL]|8[NT]|9[AN])|R(0[ABCEGHJ-M]|1[ABN]|2[CEGHJ-NPRV-Y]|3[ABCEGHJ-NPRSTV-Y]|4[AHJKL]|5[AGH]|6[MW]|7[ABCN]|8[AN]|9[A])|S(0[ACEGHJ-NP]|2[V]|3[N]|4[AHLNPRSTV-Z]|6[HJKVWX]|7[HJ-NPRSTVW]|9[AHVX])|T(0[ABCEGHJ-MPV]|1[ABCGHJ-MPRSV-Y]|2[ABCEGHJ-NPRSTV-Z]|3[ABCEGHJ-NPRZ]|4[ABCEGHJLNPRSTVX]|5[ABCEGHJ-NPRSTV-Z]|6[ABCEGHJ-NPRSTVWX]|7[AENPSVXYZ]|8[ABCEGHLNRSVWX]|9[ACEGHJKMNSVWX])|V(0[ABCEGHJ-NPRSTVWX]|1[ABCEGHJ-NPRSTV-Z]|2[ABCEGHJ-NPRSTV-Z]|3[ABCEGHJ-NRSTV-Y]|4[ABCEGK-NPRSTVWXZ]|5[ABCEGHJ-NPRSTV-Z]|6[ABCEGHJ-NPRSTV-Z]|7[ABCEGHJ-NPRSTV-Y]|8[ABCGJ-NPRSTV-Z]|9[ABCEGHJ-NPRSTV-Z])|X(0[ABCGX]|1[A])|Y(0[AB]|1[A]))[ ]?[0-9]{1}[ABCEGHJ-NPRSTV-Z]{1}[0-9]{1}$
-      ca_postcode_regex = /^[A-Z]{1}[\d]{1}[A-Z]{1}[ ]?[\d]{1}[A-Z]{1}[\d]{1}$/
-      return !(query =~ ca_postcode_regex).nil?
-    end
-
-    def self.is_coordinates?(query)
-      coordinates_regex = /^[-]?[0-9\.]+[,]{1}[-]?[0-9\.]+$/
-      return !(query =~ coordinates_regex).nil?
-    end
-    
-    def self.is_icao?(query)
-      # allow any 3 or 4 letter word ... unfortunately this means some locations
-      # (ie Utah, Goa, Kiev, etc) will be detected as ICAO.  This won't matter for
-      # returning weather results ... it will just effect what happens to the query.
-      # For example, wunderground will accept :icao above :coordinates and :geocode,
-      # which means that a city like Kiev would normally get converted to :coordinates
-      # but in this case it will be detected as :icao so it will be passed as is.
-      # Currently, only wunderground accepts ICAO, and they process ICAO the same as a
-      # city name, so it doesn't matter.
-      icao_regex = /^[A-Za-z]{3,4}$/
-      return !(query =~ icao_regex).nil?
-    end
-    
-    #
-    # CONVERTERS
-    #
-    
-    # this will take all query formats and convert them to coordinates
-    # accepts- :zipcode, :postalcode, :geocode, :icao
-    # returns- :coordinates
-    # if the conversion fails, return nil
-    def self.to_coordinates(query, format)
-      country_code = self.format_to_country_code(format)
-      geo = self.geocode(query, country_code)
-      country_code ||= geo.country_code if geo
-      return nil unless geo && geo.longitude && geo.latitude
-      ["#{geo.latitude},#{geo.longitude}", country_code, geo]
-    end
-    
-    # this will take all query formats and convert them to coorinates
-    # accepts- :zipcode, :postalcode, :coordinates, :icao
-    # returns- :geocode
-    def self.to_geocode(query, format)
-      perform_geocode = false
-      perform_geocode = true if self.has_geocode_key?
-      
-      # some formats can't convert, no need to geocode then
-      skip_formats = [:postalcode]
-      perform_geocode = false if skip_formats.include?(format)
-      
-      country_code = self.format_to_country_code(format)
-      if perform_geocode
-        geo = self.geocode(query, country_code)
-        country_code ||= geo.country_code if geo
-        # different formats have different acceptance criteria
-        q = nil
-        case format
-        when :icao
-          return nil unless geo && geo.address && geo.country
-          q = "#{geo.address}, #{geo.country}"
+      # force geocode?, unless we already did
+      #
+      if Barometer.force_geocode && !@geo
+        if converted_query && converted_query.geo
+          @geo = converted_query.geo
         else
-          return nil unless geo && geo.locality && geo.region && geo.country
-          q = "#{geo.locality}, #{geo.region}, #{geo.country}"
+          geo_query = Query::Format::Coordinates.to(converted_query)
+          @geo = geo_query.geo if (geo_query && geo_query.geo)
         end
-        return [q, country_code, geo]
-      else
-        # without geocoding, the best we can do is just make use the given query as
-        # the query for the "geocode" format
-        return [query, country_code, nil]
       end
-      return nil
-    end
-
-    #
-    # --- TODO ---
-    # The following methods need more coverage tests
-    #
-
-    def self.has_geocode_key?
-      # quick check to see that the Google API key exists for geocoding
-      self.google_geocode_key && !self.google_geocode_key.nil?
-    end
-    
-    # if Graticule exists, use it, otherwise use HTTParty
-    def self.geocode(query, country_code=nil)   
-      use_graticule = false
-      unless Barometer::skip_graticule
-        begin
-          require 'rubygems'
-          require 'graticule'
-          $:.unshift(File.dirname(__FILE__))
-          # load some changes to Graticule
-          # TODO: attempt to get changes into Graticule gem
-          require 'extensions/graticule'
-          use_graticule = true
-        rescue LoadError
-          # do nothing, we will use HTTParty
-        end
-      end
-  
-      if use_graticule
-        geo = self.geocode_graticule(query, country_code)
-      else
-        geo = self.geocode_httparty(query, country_code)
-      end
-      geo
-    end
-    
-    def self.geocode_graticule(query, country_code=nil)
-      return nil unless self.has_geocode_key?
-      geocoder = Graticule.service(:google).new(self.google_geocode_key)
-      location = geocoder.locate(query, country_code)
-      geo = Barometer::Geo.new(location)
-    end
-
-    def self.geocode_httparty(query, country_code=nil)
-      return nil unless self.has_geocode_key?
-      location = Barometer::Service.get(
-        "http://maps.google.com/maps/geo",
-        :query => {
-          :gl => country_code,
-          :key => self.google_geocode_key,
-          :output => "xml",
-          :q => query
-        },
-        :format => :xml
-      )['kml']['Response']
-      geo = Barometer::Geo.new(location)
-    end
-    
-    def self.format_to_country_code(format)
-      return nil unless format
-      case format
-      when :zipcode
-        country_code = "US"
-      when :postalcode
-        country_code = "CA"
-      else
-        country_code = nil
-      end
-      country_code
+      
+      converted_query
     end
     
-    # todo, the fist letter in a 4-letter icao can designate country:
-    # c=canada
-    # k=usa
-    # etc...
-    # def self.icao_to_country_code(icao_code)
-    #   return unless icao_code.is_a?(String)
-    #   country_code = nil
-    #   if icao_code.size == 4
-    #     case icao_code.first_letter
-    #     when "C"
-    #       country_code = "CA"
-    #     when "K"
-    #       country_code = "US"
-    #     end
-    #     if coutry_code.nil?
-    #       case icao_code.first_two_letters
-    #       when "ET"
-    #         country_code = "GERMANY"
-    #       end
-    #     end
-    #   end  
-    #   country_code
-    # end
-
   end
 end  

data/lib/barometer/services.rb

@@ -1,6 +1,16 @@
 $:.unshift(File.dirname(__FILE__))
 
-require 'services/service'
-require 'services/wunderground'
-require 'services/google'
-require 'services/yahoo'
+# weather services
+#
+require 'weather_services/service'
+require 'weather_services/wunderground'
+require 'weather_services/google'
+require 'weather_services/yahoo'
+require 'weather_services/weather_dot_com'
+
+#
+# web services (non weather)
+#
+require 'web_services/web_service'
+require 'web_services/geocode'
+require 'web_services/weather_id'

data/lib/barometer/translations/icao_country_codes.yml

@@ -0,0 +1,9 @@
+# first term - icao code
+# second term - standard country_code
+#
+one_letter:
+    C : CA
+    K : US
+    
+two_letter:
+    ET : DE

data/lib/barometer/translations/weather_country_codes.yml

@@ -0,0 +1,17 @@
+# first term - weather.com non-standard country_code
+# second term - standard country_code
+#
+AS : AU
+BF : BS
+CS : CR
+CH : CN
+CI : CL
+EI : IE
+GM : DE
+HO : HN
+IS : IL
+JA : JP
+PO : PT
+SP : ES
+SN : SG
+

data/lib/barometer/weather.rb

@@ -1,22 +1,25 @@
 module Barometer
-  
+  #
+  # Weather
+  #
+  # holds all the measurements taken and provdes
+  # methods to interact with the data
+  #
   class Weather
     
-    # hash of measurements indexed by :source
     attr_accessor :measurements
     
-    def initialize
-      @measurements = []
-    end
+    def initialize; @measurements = []; end
     
-    # the default source is the first source/measurement that we
-    # have successful results for
+    # the default measurement is the first successful measurement
+    #
     def default
       return nil unless self.sources
       self.source(self.sources.first)
     end
     
     # find the measurement for the given source, if it exists
+    #
     def source(source)
       raise ArgumentError unless (source.is_a?(String) || source.is_a?(Symbol))
       @measurements.each do |measurement|
@@ -26,6 +29,7 @@ module Barometer
     end
     
     # list successful sources
+    #
     def sources
       @measurements.collect {|m| m.source.to_sym if m.success?}.compact
     end
@@ -34,6 +38,7 @@ module Barometer
     # Quick access methods
     #
     
+    def metric?; self.default ? self.default.metric? : true; end
     def current; (default = self.default) ? default.current : nil; end
     def forecast; (default = self.default) ? default.forecast : nil; end
     def now; self.current; end
@@ -48,11 +53,16 @@ module Barometer
       default && default.forecast ? default.forecast[1] : nil
     end
     
+    # measurement search
+    # this will search the default measurements forecasts looking for
+    # the matching date
+    #
     def for(query)
       default = self.default
       default && default.forecast ? default.for(query) : nil
     end
     
+    
     #
     # helper methods
     #
@@ -64,18 +74,23 @@ module Barometer
     # averages
     #
     
-    def metric?
-      self.default ? self.default.metric? : true
-    end
-    
     # this assumes calculating for current, and that "to_f" for a value
     # will return the value needed
     # value_name = the name of the value we are averaging
+    # if a measurement has weighting, it will respect that
+    #
     def current_average(value_name)
       values = []
       @measurements.each do |measurement|
-        values << measurement.current.send(value_name).to_f if measurement.success? &&
-          measurement.current.send(value_name)
+        if measurement.weight && measurement.weight > 1
+          measurement.weight.times do
+            values << measurement.current.send(value_name).to_f if measurement.success? &&
+              measurement.current.send(value_name)
+          end
+        else
+          values << measurement.current.send(value_name).to_f if measurement.success? &&
+            measurement.current.send(value_name)
+        end
       end
       values.compact!
       return nil unless values && values.size > 0
@@ -85,7 +100,7 @@ module Barometer
     def average(value_name, do_average=true, class_name=nil)
       if class_name
         if do_average
-          avg = Barometer.const_get(class_name).new(self.metric?)
+          avg = Data.const_get(class_name).new(self.metric?)
           avg << self.current_average(value_name)
         else
           avg = self.now.send(value_name)
@@ -97,6 +112,7 @@ module Barometer
     end
       
     # average of all values
+    #
     def humidity(do_average=true); average("humidity",do_average); end
     def temperature(do_average=true); average("temperature",do_average,"Temperature"); end
     def wind(do_average=true); average("wind",do_average,"Speed"); end
@@ -123,61 +139,66 @@ module Barometer
     # pass the question on to each successful measurement until we get an answer
     #
     
-    def windy?(threshold=10, utc_time=Time.now.utc)
+    def windy?(threshold=10, time_string=nil)
+      local_datetime = Data::LocalDateTime.parse(time_string)
       raise ArgumentError unless (threshold.is_a?(Fixnum) || threshold.is_a?(Float))
-      raise ArgumentError unless utc_time.is_a?(Time)
+      raise ArgumentError unless (local_datetime.nil? || local_datetime.is_a?(Data::LocalDateTime))
       
       is_windy = nil
       @measurements.each do |measurement|
         if measurement.success?
-          is_windy = measurement.windy?(threshold, utc_time)
+          is_windy = measurement.windy?(threshold, local_datetime)
           return is_windy if !is_windy.nil?
         end
       end
       is_windy
     end
 
-    def wet?(threshold=50, utc_time=Time.now.utc)
+    def wet?(threshold=50, time_string=nil)
+      local_datetime = Data::LocalDateTime.parse(time_string)
       raise ArgumentError unless (threshold.is_a?(Fixnum) || threshold.is_a?(Float))
-      raise ArgumentError unless utc_time.is_a?(Time)
+      raise ArgumentError unless (local_datetime.nil? || local_datetime.is_a?(Data::LocalDateTime))
       
       is_wet = nil
       @measurements.each do |measurement|
         if measurement.success?
-          is_wet = measurement.wet?(threshold, utc_time)
+          is_wet = measurement.wet?(threshold, local_datetime)
           return is_wet if !is_wet.nil?
         end
       end
       is_wet
     end
 
-    def day?(utc_time=Time.now.utc)
-      raise ArgumentError unless utc_time.is_a?(Time)
+    def day?(time_string=nil)
+      local_datetime = Data::LocalDateTime.parse(time_string)
+      raise ArgumentError unless (local_datetime.nil? || local_datetime.is_a?(Data::LocalDateTime))
       
       is_day = nil
       @measurements.each do |measurement|
         if measurement.success?
-          is_day = measurement.day?(utc_time)
+          is_day = measurement.day?(local_datetime)
           return is_day if !is_day.nil?
         end
       end
       is_day
     end
 
-    def night?(utc_time=Time.now.utc)
-      raise ArgumentError unless utc_time.is_a?(Time)
-      is_day = self.day?(utc_time)
+    def night?(time_string=nil)
+      local_datetime = Data::LocalDateTime.parse(time_string)
+      raise ArgumentError unless (local_datetime.nil? || local_datetime.is_a?(Data::LocalDateTime))
+      is_day = self.day?(local_datetime)
       is_day.nil? ? nil : !is_day
     end
 
-    def sunny?(utc_time=Time.now.utc)
-      raise ArgumentError unless utc_time.is_a?(Time)
+    def sunny?(time_string=nil)
+      local_datetime = Data::LocalDateTime.parse(time_string)
+      raise ArgumentError unless (local_datetime.nil? || local_datetime.is_a?(Data::LocalDateTime))
       
       is_sunny = nil
       @measurements.each do |measurement|
         if measurement.success?
-          return false if self.day?(utc_time) == false
-          is_sunny = measurement.sunny?(utc_time)
+          return false if self.day?(local_datetime) == false
+          is_sunny = measurement.sunny?(local_datetime)
           return is_sunny if !is_sunny.nil?
         end
       end