barometer 0.3.2 → 0.5.0

data/lib/barometer/data/local_datetime.rb

@@ -0,0 +1,137 @@
+require 'date'
+module Barometer
+  #
+  # A simple DateTime class
+  # 
+  # A time class that represents the local date_time ...
+  # it has no concept of time zone
+  #
+  class Data::LocalDateTime < Data::LocalTime
+    
+    attr_reader :year, :month, :day
+
+    def initialize(y,mon,d,h=0,m=0,s=0)
+      raise(ArgumentError, "invalid date") unless y && mon && d && Date.civil(y,mon,d)
+      @year = y
+      @month = mon
+      @day = d
+      super(h,m,s)
+      self
+    end
+    
+    def year=(y)
+      unless y && y.is_a?(Fixnum) && Date.civil(y,@month,@day)
+        raise(ArgumentError, "invalid year")
+      end
+      @year = y
+    end
+    
+    def month=(m)
+      unless m && m.is_a?(Fixnum) && Date.civil(@year,m,@day)
+        raise(ArgumentError, "invalid month")
+      end
+      @month = m
+    end
+    
+    def day=(d)
+      unless d && d.is_a?(Fixnum) && Date.civil(@year,@month,d)
+        raise(ArgumentError, "invalid day")
+      end
+      @day = d
+    end
+  
+    def parse(string)
+      return unless string
+      new_date = Data::LocalDateTime.parse(string)
+      @year = new_date.year
+      @month = new_date.month
+      @day = new_date.day
+      @hour = new_date.hour
+      @min = new_date.min
+      @sec = new_date.sec
+      self
+    end
+    
+    def self.parse(string)
+      return nil unless string
+      return string if string.is_a?(Data::LocalDateTime)
+      
+      year = nil; month = nil; day = nil;
+      hour = nil; min = nil; sec = nil;
+      if string.is_a?(Time) || string.is_a?(DateTime)
+        year = string.year
+        month = string.mon
+        day = string.day
+        hour = string.hour
+        min = string.min
+        sec = string.sec
+      elsif string.is_a?(Date)
+        year = string.year
+        month = string.mon
+        day = string.day
+      elsif string.is_a?(String)
+        datetime = Time.parse(string)
+        year = datetime.year
+        month = datetime.mon
+        day = datetime.day
+        hour = datetime.hour
+        min = datetime.min
+        sec = datetime.sec
+      end
+      Data::LocalDateTime.new(year, month, day, hour, min, sec)
+    end
+    
+    # convert to a Date class
+    #
+    def to_d
+      Date.civil(@year, @month, @day)
+    end
+    
+    # convert to a DateTime class
+    #
+    def to_dt
+      DateTime.new(@year, @month, @day, @hour, @min, @sec)
+    end
+  
+    def <=>(other)
+      if other.is_a?(String) || other.is_a?(Time) || other.is_a?(DateTime) || other.is_a?(Date)
+        the_other = Data::LocalDateTime.parse(other)
+      else
+        the_other = other
+      end
+      raise ArgumentError unless the_other.is_a?(Data::LocalDateTime) || the_other.is_a?(Data::LocalTime)
+      
+      if (other.is_a?(String) || other.is_a?(Time) || other.is_a?(DateTime)) &&
+        the_other.is_a?(Data::LocalDateTime)
+        # we are counting days + seconds
+        if (_total_days <=> the_other._total_days) == 0
+          return total_seconds <=> the_other.total_seconds
+        else
+          return _total_days <=> the_other._total_days
+        end
+      elsif other.is_a?(Date) && the_other.is_a?(Data::LocalDateTime)
+        # we are counting days
+        return _total_days <=> the_other._total_days
+      elsif the_other.is_a?(Data::LocalTime)
+        # we are counting seconds
+        return total_seconds <=> the_other.total_seconds
+      end
+    end
+  
+    def to_s(time=false)
+      datetime = self.to_dt
+      format = (time ? "%Y-%m-%d %I:%M:%S %p" : "%Y-%m-%d")
+      datetime.strftime(format).downcase
+    end
+    
+    def nil?; @year == 0 && @month == 0 && @day == 0 && super; end
+    
+    # this assumes all years have 366 days (which only is true for leap years)
+    # but since this is just for comparisons, this will be accurate
+    #
+    def _total_days
+      self.to_d.yday + (@year * 366)
+    end
+    
+  end
+end

data/lib/barometer/data/local_time.rb

@@ -0,0 +1,134 @@
+module Barometer
+  #
+  # A simple Time class
+  # 
+  # A time class that represents the local time ...
+  # it has no concept of time zone or date
+  #
+  class Data::LocalTime
+    include Comparable
+    
+    attr_reader :hour, :min, :sec
+
+    def initialize(h=0,m=0,s=0)
+      self.hour = h
+      self.min = m
+      self.sec = s
+      self
+    end
+    
+    def hour=(h)
+      raise ArgumentError unless (h.is_a?(Fixnum) || h.nil?)
+      hour_cap = 24
+      if h.to_i >= hour_cap.to_i
+        @hour = h.divmod(hour_cap)[1]
+      else
+        @hour = h
+      end
+    end
+    
+    def min=(m)
+      raise ArgumentError unless (m.is_a?(Fixnum) || m.nil?)
+      minute_cap = 60
+      if m.to_i >= minute_cap.to_i
+        result = m.divmod(minute_cap)
+        @min = result[1]
+        self.hour = @hour + result[0]
+      else
+        @min = m
+      end
+    end
+    
+    def sec=(s)
+      raise ArgumentError unless (s.is_a?(Fixnum) || s.nil?)
+      second_cap = 60
+      if s.to_i >= second_cap.to_i
+        result = s.divmod(second_cap)
+        @sec = result[1]
+        self.min = @min + result[0]
+      else
+        @sec = s
+      end
+    end
+    
+    def parse(string)
+      if string.is_a?(Time) || string.is_a?(DateTime)
+        @hour = string.hour
+        @min = string.min
+        @sec = string.sec
+      elsif string.is_a?(String)
+        time = Time.parse(string)
+        @hour = time.hour
+        @min = time.min
+        @sec = time.sec
+      end
+      self
+    end
+    
+    def self.parse(string)
+      return string if string.is_a?(Data::LocalTime)
+      local = Data::LocalTime.new
+      local.parse(string)
+      local
+    end
+    
+    # convert to a Time class
+    #
+    def to_t
+      date = Date.today
+      Time.local(date.year,date.month,date.day,@hour,@min,@sec)
+    end
+    
+    def total_seconds
+      (@hour * 60 * 60) + (@min * 60) + @sec
+    end
+
+    def <=>(other)
+      if other.is_a?(String) || other.is_a?(Time) || other.is_a?(DateTime)
+        the_other = Data::LocalTime.parse(other)
+      else
+        the_other = other
+      end
+      raise ArgumentError unless the_other.is_a?(Data::LocalTime)
+      total_seconds <=> the_other.total_seconds
+    end
+    
+    def +(seconds)
+      local_time = Data::LocalTime.new
+      if seconds.is_a?(Fixnum) || seconds.is_a?(Float)
+        local_time.sec = self.total_seconds + seconds.to_i
+      elsif seconds.is_a?(Data::LocalTime)
+        this_total = self.total_seconds + seconds.total_seconds
+        local_time.sec = this_total
+      end
+      local_time
+    end
+
+    def -(seconds)
+      local_time = Data::LocalTime.new
+      if seconds.is_a?(Fixnum) || seconds.is_a?(Float)
+        local_time.sec = self.total_seconds - seconds.to_i
+      elsif seconds.is_a?(Data::LocalTime)
+        #self.sec += seconds.total_seconds
+        this_total = self.total_seconds - seconds.total_seconds
+        local_time.sec = this_total
+      end
+      local_time
+    end
+
+    def diff(other)
+      the_other = Data::LocalTime.parse(other)
+      raise ArgumentError unless the_other.is_a?(Data::LocalTime)
+      (self.total_seconds - the_other.total_seconds).to_i.abs
+    end
+  
+    def to_s(seconds=false)
+      time = self.to_t
+      format = (seconds ? "%I:%M:%S %p" : "%I:%M %p")
+      time.strftime(format).downcase
+    end
+    
+    def nil?; @hour == 0 && @min == 0 && @sec == 0; end
+    
+  end
+end

data/lib/barometer/data/location.rb

@@ -6,7 +6,7 @@ module Barometer
   # gave the measurement data for a weather query, or the location
   # that was queried
   #
-  class Location
+  class Data::Location
     
     attr_accessor :id, :name, :city
     attr_accessor :state_name, :state_code, :country, :country_code, :zip_code
@@ -16,5 +16,10 @@ module Barometer
       [@latitude, @longitude].join(',')
     end
     
+    def to_s
+      [@name, @city, @state_name || @state_cocde,
+        @country || @country_code].compact.join(', ')
+    end
+    
   end
 end

data/lib/barometer/data/measurement.rb

@@ -12,34 +12,35 @@ module Barometer
   # - time_zone information (for the location in question)
   # - weather station information (for the station that gave collected the data)
   #
-  class Measurement
+  class Data::Measurement
     
-    # the weather service source
-    attr_reader :source
-    # current and forecasted data
+    attr_reader :source, :weight
+    attr_reader :measured_at, :utc_time_stamp
     attr_reader :current, :forecast
-    attr_reader :timezone, :station, :location
-    attr_reader :success, :time
-    attr_accessor :metric
+    attr_reader :timezone, :station, :location, :links
+    attr_reader :success
+    attr_accessor :metric, :query, :format
     
     def initialize(source=nil, metric=true)
       @source = source
       @metric = metric
       @success = false
+      @weight = 1
+      @links = {}
     end
     
     def success!
-      if current && current.temperature && !current.temperature.c.nil?
-        @success = true
-      end
+       current && current.temperature &&
+         !current.temperature.c.nil? && @success = true
     end
     
-    def stamp!; @time = Time.now.utc; end
+    def stamp!; @utc_time_stamp = Time.now.utc; end
     def success?; @success; end
     def metric?; @metric; end
     def metric!; @metric=true; end
     def imperial!; @metric=false; end
     
+    #
     # this will tell us if the measurement is still current ... if it is still
     # current this means that the CurrentMeasurement can still used as now
     #
@@ -51,12 +52,17 @@ module Barometer
     # and then you want to know if self.windy?(5_hours_in_future) ... we could
     # not use the current data for this answser as the time 5_hours_in_future
     # is not current
-    def current?(utc_time=Time.now.utc)
-      return false unless @time
-      raise ArgumentError unless utc_time.is_a?(Time)
+    #
+    def current?(local_time=nil)
+      current_at = ((self.current && self.current.current_at) ?
+        self.current.current_at : self.measured_at)
+      
+      local_time = (local_time.nil? ? current_at : Data::LocalTime.parse(local_time))
+      return false unless local_time
+      raise ArgumentError unless local_time.is_a?(Data::LocalTime)
+      
       hours_still_current = 4
-      difference = (@time - utc_time).to_i
-      difference = (difference*(-1)).to_i if difference < 0
+      difference = (local_time.diff(current_at)).to_i.abs
       difference <= (60*60*hours_still_current).to_i
     end
     
@@ -73,16 +79,18 @@ module Barometer
       
       # Format date into a Date class
       date = case date.class.name
-      when 'String'
-        Date.parse(date)
       when 'Date'
         date
-      when 'DateTime'
-        Date.new(date.year, date.month, date.day)
+      when 'Data::LocalDateTime'
+        date.to_d
+      when 'String'
+        Date.parse(date)
       when 'Time'
         Date.new(date.year, date.month, date.day)
+      when 'DateTime'
+        Date.new(date.year, date.month, date.day)
       end
-
+      
       day = nil
       @forecast.each do |f|
         day = f if date == f.date
@@ -90,21 +98,24 @@ module Barometer
       return day
     end
     
+    #
+    # accesors (with input checking)
+    #
+    
     def source=(source)
       raise ArgumentError unless source.is_a?(Symbol)
       @source = source
     end
     
-    def time=(time=Time.now.utc)
+    def utc_time_stamp=(time=Time.now.utc)
       raise ArgumentError unless time.is_a?(Time)
-      @time = time
+      @utc_time_stamp = time
     end
     
     def current=(current)
-      raise ArgumentError unless current.is_a?(Barometer::CurrentMeasurement)
+      raise ArgumentError unless current.is_a?(Data::CurrentMeasurement)
       @current = current
       self.stamp!
-      # self-determine success
       self.success!
     end
     
@@ -114,47 +125,65 @@ module Barometer
     end
     
     def timezone=(timezone)
-      #raise ArgumentError unless timezone.is_a?(String)
-      raise ArgumentError unless timezone.is_a?(Barometer::Zone)
+      raise ArgumentError unless timezone.is_a?(Data::Zone)
       @timezone = timezone
     end
     
     def station=(station)
-      raise ArgumentError unless station.is_a?(Barometer::Location)
+      raise ArgumentError unless station.is_a?(Data::Location)
       @station = station
     end
     
     def location=(location)
-      raise ArgumentError unless location.is_a?(Barometer::Location)
+      raise ArgumentError unless location.is_a?(Data::Location)
       @location = location
     end
     
+    def weight=(weight)
+      raise ArgumentError unless weight.is_a?(Fixnum)
+      @weight = weight
+    end
+    
+    def links=(links)
+      raise ArgumentError unless links.is_a?(Hash)
+      @links = links
+    end
+    
+    def measured_at=(measured_at)
+      raise ArgumentError unless measured_at.is_a?(Data::LocalTime)
+      @measured_at = measured_at
+    end
+    
     #
     # simple questions
     # pass questions to the source
     #
     
-    def windy?(threshold=10, utc_time=Time.now.utc)
+    def windy?(threshold=10, time_string=nil)
+      local_datetime = Data::LocalDateTime.parse(time_string) if time_string
       raise ArgumentError unless (threshold.is_a?(Fixnum) || threshold.is_a?(Float))
-      raise ArgumentError unless utc_time.is_a?(Time)
-      Barometer::Service.source(@source).windy?(self, threshold, utc_time)
+      raise ArgumentError unless (local_datetime.is_a?(Data::LocalDateTime) || local_datetime.nil?)
+      Barometer::WeatherService.source(@source).windy?(self, threshold, local_datetime)
     end
     
-    def wet?(threshold=50, utc_time=Time.now.utc)
+    def wet?(threshold=50, time_string=nil)
+      local_datetime = Data::LocalDateTime.parse(time_string) if time_string
       raise ArgumentError unless (threshold.is_a?(Fixnum) || threshold.is_a?(Float))
-      raise ArgumentError unless utc_time.is_a?(Time)
-      Barometer::Service.source(@source).wet?(self, threshold, utc_time)
+      raise ArgumentError unless (local_datetime.is_a?(Data::LocalDateTime) || local_datetime.nil?)
+      Barometer::WeatherService.source(@source).wet?(self, threshold, local_datetime)
     end
     
-    def day?(utc_time=Time.now.utc)
-      raise ArgumentError unless utc_time.is_a?(Time)
-      Barometer::Service.source(@source).day?(self, utc_time)
+    def day?(time_string=nil)
+      local_datetime = Data::LocalDateTime.parse(time_string) if time_string
+      raise ArgumentError unless (local_datetime.is_a?(Data::LocalDateTime) || local_datetime.nil?)
+      Barometer::WeatherService.source(@source).day?(self, local_datetime)
     end
     
-    def sunny?(utc_time=Time.now.utc)
-      raise ArgumentError unless utc_time.is_a?(Time)
-      return false if self.day?(utc_time) == false
-      Barometer::Service.source(@source).sunny?(self, utc_time)
+    def sunny?(time_string=nil)
+      local_datetime = Data::LocalDateTime.parse(time_string) if time_string
+      raise ArgumentError unless (local_datetime.is_a?(Data::LocalDateTime) || local_datetime.nil?)
+      return false if self.day?(local_datetime) == false
+      Barometer::WeatherService.source(@source).sunny?(self, local_datetime)
     end
     
   end