weatherzone 0.5.8

data/lib/weatherzone/helpers/almanac_element.rb

@@ -0,0 +1,28 @@
+module Weatherzone  
+  module Helpers
+    module AlmanacElement
+
+      def self.included(klass)
+        klass.class_eval do
+          def self.almanac_element(type, subtype, options={})
+            period      = options[:period]
+            method_name = options[:as]
+            attributes  = options[:with_attributes]
+
+            method_name = "#{subtype.downcase.gsub(' ', '_')}_#{type.downcase.gsub(' ', '_')}" unless method_name
+    
+            with_options = {:type => type, :subtype => subtype}
+            with_options.merge!(:period => period) if period
+    
+            element :almanac_element, :with => with_options, :as => method_name
+    
+            attributes.each do |attr_name|
+              element :almanac_element, :value => attr_name, :with => with_options, :as => "#{method_name}_#{attr_name}"
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/weatherzone/helpers/date_parser.rb

@@ -0,0 +1,33 @@
+module Weatherzone  
+  module Helpers
+    module DateParser
+      def self.included(klass)
+        klass.class_eval do
+
+          def self.interpret_as_date(*methods)
+            methods.each do |method_name|
+              define_method method_name do
+                Date.parse(instance_variable_get("@#{method_name}"))
+              end
+            end
+          end
+
+          def self.interpret_as_time(*methods)
+            methods.each do |method_name|
+              has_attribute :tz, :on_elements => methods
+              define_method "#{method_name}_utc" do
+                tz = TZInfo::Timezone.get("Australia/#{send("#{method_name}_tz")}")
+                tz.local_to_utc(Time.parse(instance_variable_get("@#{method_name}")))
+              end
+              define_method method_name do
+                tz = TZInfo::Timezone.get("Australia/#{send("#{method_name}_tz")}")
+                tz.utc_to_local send("#{method_name}_utc")
+              end
+            end
+          end
+          
+        end
+      end
+    end
+  end
+end

data/lib/weatherzone/helpers/units.rb

@@ -0,0 +1,76 @@
+require 'bigdecimal'
+
+module Weatherzone  
+  module Helpers
+    module Units
+      def self.included(klass)
+        klass.class_eval do
+          
+          self.temperature_attributes = []
+          self.forecast_temperature_attributes = []
+          self.observed_temperature_attributes = []
+
+          def self.temperature(*methods)
+            self.temperature_attributes = methods
+            value_plus_unit_readers *methods
+          end
+          
+          def self.forecast_temperature(*methods)
+            self.forecast_temperature_attributes = methods
+            value_plus_unit_readers *methods
+          end
+
+          def self.observed_temperature(*methods)
+            self.observed_temperature_attributes = methods
+            value_plus_unit_readers *methods
+          end
+          
+          def self.value_plus_unit_readers(*methods)
+            methods.each do |method_name|
+              define_method method_name do
+                value = send("#{method_name}_value")
+                if settings.strip_scale_from_units
+                  value ? "#{value}#{instance_variable_get("@#{method_name}_units")}".gsub("C", "") : nil
+                else
+                  value ? "#{value}#{instance_variable_get("@#{method_name}_units")}".gsub("C", Weather.temperature_unit || "C") : nil
+                end
+              end
+              
+              define_method "#{method_name}_value" do
+                ivar_name = instance_variable_names.include?("@#{method_name}_value") ? "@#{method_name}_value" : "@#{method_name}"
+                value     = instance_variable_get(ivar_name)
+                fahrenheit_conversion_required?(method_name) ? to_fahrenheit(value, method_name) : value
+              end
+              
+              define_method "#{method_name}_units" do
+                ivar_name = "@#{method_name}_units"
+                unit      = instance_variable_get(ivar_name)
+                fahrenheit_conversion_required?(method_name) ? unit.gsub("C", temperature_unit) : unit
+              end
+            end
+          end
+
+          def fahrenheit_conversion_required?(method_name)
+            temperature_unit == "F" && (self.class.forecast_temperature_attributes.include?(method_name) || self.class.observed_temperature_attributes.include?(method_name))
+          end
+
+          def to_fahrenheit(value, method_name)
+            temp_f = (BigDecimal(value) * BigDecimal("1.8")) + BigDecimal("32")
+            case
+            when self.class.forecast_temperature_attributes.include?(method_name)
+              temp_f.round(0).to_i.to_s
+            when self.class.observed_temperature_attributes.include?(method_name)
+              temp_f.round(1).to_s("F")
+            else
+              temp_f.to_s("F")
+            end
+          end
+          
+          def temperature_unit
+            settings.weather_class.temperature_unit
+          end
+        end
+      end
+    end
+  end
+end

data/lib/weatherzone/resource.rb

@@ -0,0 +1,46 @@
+require 'weatherzone/connection'
+
+module Weatherzone
+
+  class Resource
+    
+    include SAXMachine
+
+    class_inheritable_accessor :top_level_element, :temperature_unit, :temperature_attributes, :forecast_temperature_attributes, :observed_temperature_attributes
+
+    def self.inherited(klass)
+      klass.class_eval do
+        self.top_level_element ||= self.name.downcase
+      end
+    end
+
+    def self.has_elements(*elements)
+      elements.each do |e|
+        element e
+      end
+    end
+
+    def self.has_attribute(attr_name, options={})
+      element_name = options[:on_elements] || self.top_level_element
+      if element_name.is_a? Array
+        element_name.each do |e|
+          element e, :value => attr_name, :as => "#{e}_#{attr_name}"
+        end
+      else
+        method_name = (element_name == self.top_level_element) ? "#{attr_name}" : "#{element_name}_#{attr_name}"
+        element element_name, :value => attr_name, :as => method_name
+      end
+    end
+
+    def settings
+      Weatherzone::Settings.instance
+    end
+    # def hash
+    #   @fields.collect { |field_name, data_element| data_element.hash }.hash
+    # end
+    # 
+    # def eql?(other)
+    #   self.hash == other.hash
+    # end            
+  end
+end

data/lib/weatherzone/resources/almanac.rb

@@ -0,0 +1,18 @@
+class Almanac < Weatherzone::Resource  
+  attributes :month_num, :month_name, :date_start, :date_end
+
+  elements :almanac_period, :as => :almanac_periods, :class => AlmanacPeriod
+  
+  def mtd
+    @mtd ||= almanac_periods.detect { |ap| ap.code == "MTD" }
+  end
+
+  def ytd
+    @ytd ||= almanac_periods.detect { |ap| ap.code == "YTD" }
+  end
+
+  def extremes
+    @extremes ||= almanac_periods.detect { |ap| ap.code == "Extremes" }
+  end
+
+end

data/lib/weatherzone/resources/almanac_period.rb

@@ -0,0 +1,51 @@
+class AlmanacPeriod < Weatherzone::Resource  
+
+  attributes :code, :title, :month_name, :from, :to
+
+  include Weatherzone::Helpers::AlmanacElement
+  include Weatherzone::Helpers::DateParser
+  include Weatherzone::Helpers::Units
+  
+  # Rainfall this month
+  almanac_element "Rainfall", "average", :with_attributes => [:value, :units, :days], :period => "long term", :as => :avg_rainfall_this_month
+  almanac_element "Rainfall", "driest",  :with_attributes => [:value, :units, :date], :period => "this month", :as => :driest_rainfall_this_month
+  almanac_element "Rainfall", "wettest", :with_attributes => [:value, :units, :date], :period => "this month", :as => :wettest_rainfall_this_month
+  almanac_element "Rainfall", "so far",  :with_attributes => [:value, :units, :days, :from, :to], :period => "this month", :as => :rainfall_this_month
+  almanac_element "Rainfall", "so far",  :with_attributes => [:value, :units, :days, :from, :to], :period => "this time last year", :as => :rainfall_this_time_last_year
+  
+  # Rainfall this year
+  almanac_element "Rainfall", "average", :with_attributes => [:value, :units, :days], :period => "to the end of this month", :as => :avg_rainfall_this_year
+  almanac_element "Rainfall", "driest",  :with_attributes => [:value, :units, :date], :period => "this year", :as => :driest_rainfall_this_year
+  almanac_element "Rainfall", "wettest", :with_attributes => [:value, :units, :date], :period => "this year", :as => :wettest_rainfall_this_year
+  almanac_element "Rainfall", "so far",  :with_attributes => [:value, :units, :days, :from, :to], :period => "this year", :as => :rainfall_this_year
+  
+  # Temperature this month
+  almanac_element "Temperature", "average max", :with_attributes => [:value, :units], :period => "long term", :as => :avg_max_temp_long_term
+  almanac_element "Temperature", "average min", :with_attributes => [:value, :units], :period => "long term", :as => :avg_min_temp_long_term
+  almanac_element "Temperature", "average max", :with_attributes => [:value, :units, :from, :to], :period => "this month", :as => :avg_max_temp_this_month
+  almanac_element "Temperature", "average min", :with_attributes => [:value, :units, :from, :to], :period => "this month", :as => :avg_min_temp_this_month
+  almanac_element "Temperature", "hottest",     :with_attributes => [:value, :units, :date], :period => "this month", :as => :hottest_temp_this_month
+  almanac_element "Temperature", "coldest",     :with_attributes => [:value, :units, :date], :period => "this month", :as => :coldest_temp_this_month
+  
+  # Temperature this year
+  almanac_element "Temperature", "hottest",     :with_attributes => [:value, :units, :date], :period => "this year", :as => :hottest_temp_this_year
+  almanac_element "Temperature", "coldest",     :with_attributes => [:value, :units, :date], :period => "this year", :as => :coldest_temp_this_year
+  
+  # Extremes
+  almanac_element "Extreme", "coldest", :with_attributes => [:period, :year, :value, :units], :as => :coldest_extreme
+  almanac_element "Extreme", "hottest", :with_attributes => [:period, :year, :value, :units], :as => :hottest_extreme
+  almanac_element "Extreme", "wettest", :with_attributes => [:period, :year, :value, :units], :as => :wettest_extreme
+  almanac_element "Extreme", "highest", :with_attributes => [:period, :date, :value, :units], :as => :highest_extreme_temp
+  almanac_element "Extreme", "lowest",  :with_attributes => [:period, :date, :value, :units], :as => :lowest_extreme_temp
+  
+  interpret_as_date :driest_rainfall_this_month_date, :wettest_rainfall_this_month_date, :driest_rainfall_this_year_date, :wettest_rainfall_this_year_date,
+    :hottest_temp_this_month_date, :coldest_temp_this_month_date, :hottest_temp_this_year_date, :coldest_temp_this_year_date, :highest_extreme_temp_date,
+    :lowest_extreme_temp_date
+  
+  temperature :avg_max_temp_long_term, :avg_min_temp_long_term, :avg_max_temp_this_month, :avg_min_temp_this_month, :hottest_temp_this_month, :coldest_temp_this_month, 
+      :hottest_temp_this_year, :coldest_temp_this_year, :coldest_extreme, :hottest_extreme, :wettest_extreme, :highest_extreme_temp, :lowest_extreme_temp
+      
+  value_plus_unit_readers :avg_rainfall_this_month, :driest_rainfall_this_month, :wettest_rainfall_this_month, :rainfall_this_month, :rainfall_this_time_last_year,
+    :avg_rainfall_this_year, :driest_rainfall_this_year, :wettest_rainfall_this_year, :rainfall_this_year
+  
+end

data/lib/weatherzone/resources/climate_period.rb

@@ -0,0 +1,8 @@
+class ClimatePeriod < Weatherzone::Resource
+  include Weatherzone::Helpers::Units
+  attributes :name
+  has_elements :mean_temp_min_c, :mean_temp_max_c, :rain_days, :mean_rainfall_mm
+  has_attribute :units, :on_elements => [:mean_temp_min_c, :mean_temp_max_c, :mean_rainfall_mm]
+  temperature :mean_temp_min_c, :mean_temp_max_c
+  value_plus_unit_readers :mean_rainfall_mm
+end

data/lib/weatherzone/resources/conditions.rb

@@ -0,0 +1,19 @@
+class Conditions < Weatherzone::Resource  
+
+  include Weatherzone::Helpers::Units
+  
+  has_elements :obs_time_utc, :obs_time_local, :temp_c, :dp_c, :rh, 
+    :wind_dir_degrees, :wind_dir_compass, :wind_speed_kph, :wind_speed_kts,
+    :wind_gust_kph, :wind_gust_kts, :feels_like_c, :rainfall_mm, :pressure_qnh_hpa
+
+  has_attribute :units, :on_elements => [:temp_c, :dp_c, :rh, :wind_dir_degrees, :wind_speed_kph, :wind_speed_kts, 
+                                          :wind_gust_kph, :wind_gust_kts, :feels_like_c, :pressure_qnh_hpa, :rainfall_mm]
+  has_attribute :period, :on_elements => :rainfall_mm
+
+  observed_temperature :temp_c
+  value_plus_unit_readers :dp_c, :rh, :wind_speed_kph, :wind_speed_kts, :wind_gust_kph, :wind_gust_kts, :feels_like_c, :rainfall_mm, :pressure_qnh_hpa
+
+  def wind_dir_and_speed
+    wind_dir_compass || wind_speed_kph ? "#{wind_dir_compass} #{wind_speed_kph}" : nil
+  end
+end

data/lib/weatherzone/resources/country.rb

@@ -0,0 +1,4 @@
+class Country < Weatherzone::Resource
+  attributes :code, :name
+  elements :location, :as => :locations, :class => Location
+end

data/lib/weatherzone/resources/daily_observation.rb

@@ -0,0 +1,10 @@
+class DailyObservation < Weatherzone::Resource
+  include Weatherzone::Helpers::Units
+
+  has_elements :day_name, :date, :temp_min_c, :temp_max_c, :rainfall_mm
+  has_attribute :units, :on_elements => [:temp_min_c, :temp_max_c, :rainfall_mm]
+  has_attribute :period, :on_elements => :rainfall_mm
+
+  temperature :temp_min_c, :temp_max_c
+  value_plus_unit_readers :rainfall_mm
+end

data/lib/weatherzone/resources/district_forecast.rb

@@ -0,0 +1,5 @@
+class DistrictForecast < Weatherzone::Resource
+  attributes :period
+  has_elements :period_name, :precis, :icon
+  has_attribute :filename, :on_elements => :icon
+end

data/lib/weatherzone/resources/forecast.rb

@@ -0,0 +1,47 @@
+class Forecast < Weatherzone::Resource
+
+  include Weatherzone::Helpers::Units
+
+  attributes :day
+
+  has_elements :day_name, :date, :temp_min_c, :temp_max_c, :prob_precip, :icon,
+    :rain_range_text, :frost_risk_text, :uv, :first_light, :sunrise, :sunset, :last_light,
+    :moonrise, :moonset, :moon_phase
+
+  has_attribute :units, :on_elements => [:temp_min_c, :temp_max_c, :prob_precip]
+  has_attribute :index, :on_elements => :uv
+  has_attribute :filename, :on_elements => :icon
+  has_attribute :phase_num, :on_elements => :moon_phase
+  has_attribute :phase_text, :on_elements => :moon_phase
+  has_attribute :image_name, :on_elements => :moon_phase
+  has_attribute :tz, :on_elements => [:first_light, :last_light, :sunset, :sunrise, :moonset, :moonrise]
+  
+  elements :point_forecast, :as => :point_forecasts, :class => PointForecast  
+
+  forecast_temperature :temp_min_c, :temp_max_c
+
+  def icon_name
+    icon_filename.split(".").first
+  end
+
+  def abbr_day_name
+    self.day_name[0..2]
+  end
+
+  def date
+    Date.parse(@date)
+  end
+
+  def chance_of_rain
+    "#{self.prob_precip}#{self.prob_precip_units}"
+  end
+
+  def min_rain
+    self.rain_range_text.split("-")[0].to_i if rain_range_text
+  end
+
+  def max_rain
+    self.rain_range_text.split("-")[1].to_i if rain_range_text
+  end
+
+end

data/lib/weatherzone/resources/historical_observation.rb

@@ -0,0 +1,57 @@
+class HistoricalObservation < Weatherzone::Resource
+
+  include Weatherzone::Helpers::Units
+  
+  has_elements :obs_time_utc, :obs_time_local, :temp_c, :dp_c, :rh, 
+    :wind_dir_degrees, :wind_dir_compass, :wind_speed_kph, :wind_speed_kts,
+    :wind_gust_kph, :wind_gust_kts, :feels_like_c, :rainfall_mm, :pressure_qnh_hpa
+  has_attribute :units, :on_elements => [:temp_c, :dp_c, :rh, :wind_dir_degrees, :wind_speed_kph, 
+                                          :wind_speed_kts, :wind_gust_kph, :wind_gust_kts, :feels_like_c, :rainfall_mm, :pressure_qnh_hpa, :rainfall_mm]
+  has_attribute :period, :on_elements => :rainfall_mm
+  
+  temperature :temp_c
+  
+  WIND_SPEED_RANGE = {
+    (0..19) => "calm",                                                                                       
+    (20..30) => "moderate",
+    (31..39) => "fresh",
+    (40..61) => "strong",
+    (62..87) => "gale",
+    (88..1.0/0) => "storm"
+  }
+  
+  WIND_SPEED_RANGE.instance_eval do
+    def find_by_speed(speed)
+      self[keys.find { |range| range.include? speed.to_i }] rescue nil    
+    end
+  end
+  
+  def obs_time_local
+    Time.parse(@obs_time_local)
+  end
+  
+  def is_on_the_half_hour?
+    obs_time_local.change(:min => 0) == obs_time_local || obs_time_local.change(:min => 30) == obs_time_local
+  end
+  
+  def is_on_the_hour?
+    obs_time_local.change(:min => 0) == obs_time_local
+  end
+  
+  def wind_speed
+    WIND_SPEED_RANGE.find_by_speed(wind_speed_kph)
+  end
+  
+  def rainfall_mm
+    @rainfall_mm || "0"
+  end
+  
+  def hash
+    obs_time_local.hash
+  end
+
+  def eql?(other)
+    self.obs_time_local == other.obs_time_local
+  end
+
+end

data/lib/weatherzone/resources/image.rb

@@ -0,0 +1,9 @@
+class Image < Weatherzone::Resource
+  include Weatherzone::Helpers::DateParser
+  has_elements :issue_day_name, :issue_time_local, :valid_time, :text, :url
+  interpret_as_time :valid_time, :issue_time_local
+
+  def forecast_date
+    valid_time.to_date
+  end
+end

data/lib/weatherzone/resources/lift.rb

@@ -0,0 +1,3 @@
+class Lift < Weatherzone::Resource
+  attributes :time, :tz, :name, :status
+end

data/lib/weatherzone/resources/location.rb

@@ -0,0 +1,100 @@
+class Location < Weatherzone::Resource  
+  attributes :type, :code, :name, :state
+
+  has_elements :lat, :long, :elevation
+  has_attribute :units, :on_elements => [:lat, :long, :elevation]
+
+  elements :forecast, :as => :forecasts, :class => Forecast
+  elements :conditions, :as => :conditions, :class => Conditions
+  elements :district_forecast, :as => :district_forecasts, :class => DistrictForecast
+  elements :state_forecast, :as => :state_forecasts, :class => StateForecast
+  elements :marine_forecast, :as => :marine_forecasts, :class => MarineForecast
+  elements :surf_report, :as => :surf_reports, :class => SurfReport
+  elements :snow_report, :as => :snow_reports, :class => SnowReport
+  elements :historical_observation, :as => :historical_observations, :class => HistoricalObservation
+  elements :daily_observations, :as => :daily_observations, :class => DailyObservation
+  elements :climate_period, :as => :climate_periods, :class => ClimatePeriod
+  elements :warning, :as => :warnings, :class => Warning
+  elements :almanac, :as => :almanacs, :class => Almanac
+  elements :tide, :as => :tides, :class => Tide
+  elements :buoy_obs, :as => :buoy_observations, :class => BuoyObservation
+  
+  elements :image, :as => :synoptic_charts, :with => {:type => "Synoptic chart"}, :class => Image
+
+  element :link, :value => :url, :as => :radar_animator, :with => {:type => "radar animator"}
+  element :link, :value => :url, :as => :radar_still, :with => {:type => "radar still"}
+  element :link, :value => :width, :as => :radar_still_width, :with => {:type => "radar still"}
+  element :link, :value => :height, :as => :radar_still_height, :with => {:type => "radar still"}
+
+  element :link, :value => :url, :as => :satellite_animator, :with => {:type => "satellite animator"}
+  element :link, :value => :url, :as => :satellite_still, :with => {:type => "satellite still"}
+
+  # override base ruby Object#type
+  attr_reader :type
+
+  def id
+    code
+  end
+
+  def current_forecast
+    @current_forecast ||= forecasts.first
+  end
+
+  def current_conditions
+    @current_conditions ||= conditions.first
+  end
+  
+  def current_district_forecast
+    @current_district_forecast ||= district_forecasts.first
+  end
+  
+  def current_district_forecast_precis
+    current_district_forecast ? current_district_forecast.precis : "District forecast unavailable"  
+  end
+  
+  def current_state_forecast
+    @current_state_forecast ||= state_forecasts.first
+  end
+  
+  def current_state_forecast_precis
+    current_state_forecast ? current_state_forecast.precis : "State forecast unavailable"
+  end
+  
+  def current_synoptic_chart
+    synoptic_chart.first
+  end
+  
+  def current_synoptic_chart_text
+    current_synoptic_chart ? current_synoptic_chart.text : "Synoptic chart unavailable"
+  end
+  
+  def current_marine_forecast
+    @marine_forecast ||= marine_forecasts.first
+  end
+  
+  def historical_observations_shifted_to_nearest_half_hour
+    obs_to_shift = historical_observations.uniq.reverse
+    historical_observations.each do |ho|
+      break if ho.is_on_the_half_hour?
+      obs_to_shift.shift
+    end
+    obs_to_shift
+  end
+  
+  def hourly_observations
+    historical_observations.uniq.reverse.select { |ho| ho.is_on_the_hour? }    
+  end
+  
+  def position
+    "(#{self.lat}&deg;S, #{self.long}&deg;E, #{self.elevation}m AMSL)"
+  end
+  
+  def url_slug
+    self.name.parameterize
+  end
+
+  def <=>(other)
+    self.name <=> other.name
+  end
+
+end