roker 0.0.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Greg
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,17 @@
+= roker
+
+Description goes here.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2009 Greg. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,55 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "roker"
+    gem.summary = %Q{Weather forecasts from weather.gov}
+    gem.description = %Q{Weather forecasts from weather.gov}
+    gem.email = "gsterndale@gmail.com"
+    gem.homepage = "http://github.com/gsterndale/roker"
+    gem.authors = ["Greg Sterndale"]
+    gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
+    gem.add_development_dependency "mocha", ">= 0.9.1"
+    gem.add_development_dependency "hpricot", ">= 0.6.164"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "roker #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/lib/numeric.rb

@@ -0,0 +1,44 @@
+class Numeric
+  SECONDS_PER_MINUTE = 60.0
+  SECONDS_PER_HOUR = SECONDS_PER_MINUTE * 60
+  SECONDS_PER_DAY = SECONDS_PER_HOUR * 24
+  SECONDS_PER_WEEK = SECONDS_PER_DAY * 7
+  SECONDS_PER_MONTH = SECONDS_PER_DAY * 30
+  SECONDS_PER_YEAR = SECONDS_PER_DAY * 365.25
+  
+  def years
+    self * SECONDS_PER_YEAR
+  end
+  alias_method :year, :years
+  
+  def months
+    self * SECONDS_PER_MONTH
+  end
+  alias_method :month, :months
+  
+  def weeks
+    self * SECONDS_PER_WEEK
+  end
+  alias_method :week, :weeks
+  
+  def days
+    self * SECONDS_PER_DAY
+  end
+  alias_method :day, :days
+  
+  def hours
+    self * SECONDS_PER_HOUR
+  end
+  alias_method :hour, :hours
+  
+  def minutes
+    self * SECONDS_PER_MINUTE
+  end
+  alias_method :minute, :minutes
+  
+  def seconds
+    self
+  end
+  alias_method :second, :seconds
+  
+end

data/lib/roker.rb

@@ -0,0 +1,173 @@
+require 'rubygems'
+require 'hpricot'
+require 'soap/wsdlDriver'
+require 'xsd/mapping'
+require 'uri'
+require 'open-uri'
+require File.dirname(__FILE__) + '/numeric'
+require File.dirname(__FILE__) + '/time'
+require File.dirname(__FILE__) + '/time_layout'
+require File.dirname(__FILE__) + '/time_span'
+require File.dirname(__FILE__) + '/weather_parameter'
+
+class ServiceError < RuntimeError; end
+
+class Roker
+  
+  attr_accessor :lat, :lng, :started_at, :ended_at
+  
+  WSDL_URL = "http://www.weather.gov/forecasts/xml/DWMLgen/wsdl/ndfdXML.wsdl"
+  WSDL_PARAMETERS = { :maxt => true, :mint => true, :temp => true, :dew => true, :appt => false, :pop12 => true, :qpf => true, :snow => false, :sky => true, :rh => true, :wspd => true, :wdir => true, :wx => false, :icons => false, :waveh => true, :incw34 => false, :incw50 => false, :incw64 => false, :cumw34 => false, :cumw50 => false, :cumw64 => false, :wgust => false, :conhazo => false, :ptornado => false, :phail => false, :ptstmwinds => false, :pxtornado => false, :pxhail => false, :pxtstmwinds => false, :ptotsvrtstm => false, :pxtotsvrtstm =>false}
+  WSDL_PRODUCT = "time-series"
+  
+  def initialize(attributes={})
+    attributes.each do |key, value|
+      self.send("#{key}=", value)
+    end
+    self.started_at, self.ended_at = self.ended_at, self.started_at if self.ended_at && self.started_at > self.ended_at
+  end
+  
+  
+  def weather_forecasts_attributes
+    @weather_forecasts_attributes ||= find_weather_forecasts_attributes
+  end
+  
+  def find_weather_forecasts_attributes
+    weather_forecasts_attributes = []
+    interval = shortest_time_span
+    self.started_at.upto(self.ended_at, interval, false) do |current_started_at|
+      current_time_span = TimeSpan.new(:start_at => current_started_at, :duration => interval)
+      current_weather_forecast_attributes = {
+        :lat => self.lat, 
+        :lng => self.lng, 
+        :started_at => current_time_span.start_at, 
+        :ended_at => current_time_span.end_at
+      }
+      parameters.each do |key, parameter|
+        current_weather_forecast_attributes[key] = parameter.value_at(current_time_span) if parameter
+      end
+      weather_forecasts_attributes << current_weather_forecast_attributes
+    end
+    weather_forecasts_attributes
+  end
+  
+  def time_layouts
+    @time_layouts ||= parse_time_layouts
+  end
+  
+  def parse_time_layouts
+    tls = {}
+    self.weather_doc.search('time-layout').each do |tl|
+      key = (tl/'layout-key').first.inner_html
+      
+      start_at = []
+      tl.search('start-valid-time').each do |s|
+        start_at << self.class.parse_time(s.inner_html)
+      end
+      
+      end_at = []
+      tl.search('end-valid-time').each do |e|
+        end_at << self.class.parse_time(e.inner_html)
+      end
+      
+      tls[key] = TimeLayout.new(:start_at => start_at, :end_at => end_at, :key => key)
+    end
+    tls
+  end
+  
+  def shortest_time_span
+    shorty = nil
+    self.time_layouts.each do |key, time_layout|
+      shorty = time_layout.interval if (shorty.nil? || shorty > time_layout.interval)
+    end
+    shorty
+  end
+  
+  def parameters
+    @parameters ||= parse_parameters
+  end
+  
+  
+  def parse_parameters
+    {
+      :maximum_temperature =>           self.parse_parameter("temperature[@type='maximum']"),
+      :minimum_temperature =>           self.parse_parameter("temperature[@type='minimum']"),
+      :temperature =>                   self.parse_parameter("temperature[@type='hourly']"),
+      :dewpoint_temperature =>          self.parse_parameter("temperature[@type='dew point']"),
+      :liquid_precipitation =>          self.parse_parameter("precipitation[@type='liquid']"),
+      :probability_of_precipitation =>  self.parse_parameter("probability-of-precipitation"),
+      :wind_speed =>                    self.parse_parameter("wind-speed[@type='sustained']"),
+      :wind_direction =>                self.parse_parameter("direction[@type='wind']"),
+      :cloud_cover =>                   self.parse_parameter("cloud-amount[@type='total']"),
+      :relative_humidity =>             self.parse_parameter("humidity[@type='relative']"),
+      :wave_height =>                   self.parse_parameter("water-state", "waves[@type='significant']")
+    }
+  end
+  
+  def parse_parameter(xpath, value_xpath=nil, calculation_method=nil)
+    element = self.weather_doc.at(xpath)
+    if element
+      time_layout_key = element.attributes['time-layout']
+      time_layout = self.time_layouts[time_layout_key]
+      values = []
+      element = element.at(value_xpath) if value_xpath
+      element.search('value').each do |val|
+        values << val.inner_html.to_f
+      end
+      WeatherParameter.new(:time_layout => time_layout, :values => values, :calculation_method => calculation_method)
+    end
+  end
+  
+  def weather_doc
+    @weather_doc ||= Hpricot::XML(self.weather_xml)
+  rescue Timeout::Error, 
+         Errno::EINVAL, 
+         Errno::ECONNRESET, 
+         EOFError,
+         Net::HTTPBadResponse, 
+         Net::HTTPHeaderSyntaxError,
+         Net::ProtocolError => e
+    service_error = ServiceError.new
+    service_error.set_backtrace(e.backtrace)
+    raise service_error
+  end
+  
+  def weather_xml
+    @weather_xml ||=  weather_xml_soap
+    # TODO can I do away with the weather_xml_soap and just use a url and URI.parse?
+    # @weather_xml ||= weather_xml_uri
+  end
+  
+protected
+  
+  def weather_xml_soap
+    soap_driver = SOAP::WSDLDriverFactory.new(WSDL_URL).create_rpc_driver
+    soap_driver.NDFDgen(self.lat, self.lng, WSDL_PRODUCT, self.started_at.strftime("%Y-%m-%dT%H:%M:%S-05:00"), self.ended_at.strftime("%Y-%m-%dT%H:%M:%S-05:00"), WSDL_PARAMETERS)
+  end
+  
+  def weather_xml_uri
+    URI.parse(self.service_url).read
+  end
+  
+  def num_days
+    return 1 unless self.ended_at
+    ((self.ended_at.beginning_of_day-self.started_at.beginning_of_day)/1.day).ceil
+  end
+  
+  def service_url
+    sprintf("http://www.weather.gov/forecasts/xml/sample_products/" + 
+            "browser_interface/ndfdBrowserClientByDay.php?" + 
+            "&format=24+hourly&numDays=%s&lat=%s&lon=%s&startDate=%s", 
+            num_days, self.lat, self.lng, self.started_at.to_s(:weather))
+  end
+  
+  def self.parse_time(str='')
+    # "2008-11-24T07:00:00-05:00"
+    str =~ /(....)-(..)-(..)T(..):(..):(..)-(..):(..)/i
+    Time.mktime($1, $2, $3, $4, $5, $6, $7, $8)
+    # Time.parse(str)
+  rescue
+    raise ServiceError, "Unsupported time format #{str}"
+  end
+  
+end

data/lib/time.rb

@@ -0,0 +1,121 @@
+class Time
+  def beginning_of_year
+    self-(self.yday-1).days-(self.hour).hours-(self.min).minutes-self.sec
+  end
+  def end_of_year
+    self.beginning_of_year + 365.days - 1.second
+  end
+  def beginning_of_month
+    self-(self.mday-1).days-(self.hour).hours-(self.min).minutes-self.sec
+  end
+  def end_of_month
+    self.beginning_of_month + 1.month - 1.second
+  end
+  def beginning_of_week
+    self-(self.wday).days-(self.hour).hours-(self.min).minutes-self.sec
+  end
+  def end_of_week
+    self.beginning_of_week + 1.week - 1.second
+  end
+  def beginning_of_day
+    self-(self.hour).hours-(self.min).minutes-self.sec
+  end
+  def end_of_day
+    self.beginning_of_day + 24.hours - 1.second
+  end
+  def beginning_of_hour
+    self-(self.min).minutes-self.sec
+    # Time.at((self.to_i/1.hour).floor*1.hour)
+  end
+  def end_of_hour
+    self.beginning_of_hour + 1.hour - 1.second
+    # Time.at((self.to_i/1.hour).floor*1.hour+1.hour)
+  end
+  def beginning_of_minute
+    self-self.sec
+    # Time.at((self.to_i/1.minute).floor*1.minute)
+  end
+  def end_of_minute
+    self.beginning_of_minute + 1.minute - 1.second
+    # Time.at((self.to_i/1.minute).floor*5.minute)
+  end
+  
+  def beginning_of(secs=1.day)
+    case secs
+    when 1.hour
+      self.beginning_of_hour
+    when 1.day
+      self.beginning_of_day
+    when 1.week
+      self.beginning_of_week
+    when 1.month
+      self.beginning_of_month
+    when 1.year
+      self.beginning_of_year
+    else
+      if secs < 1.day
+        self.beginning_of_period(secs)
+      else
+        return self
+      end
+    end
+  end
+  
+  def end_of(secs=1.day)
+    case secs
+    when 1.hour
+      self.end_of_hour
+    when 1.day
+      self.end_of_day
+    when 1.week
+      self.end_of_week
+    when 1.month
+      self.end_of_month
+    when 1.year
+      self.end_of_year
+    else
+      if secs < 1.day
+        self.end_of_period(secs)
+      else
+        return self
+      end
+    end
+  end
+  
+  def beginning_of_period(secs=5.minutes)
+    return self if secs >= 1.day/2
+    secs_today = self - self.beginning_of_day
+    periods_today = (secs_today/secs).floor
+    self.beginning_of_day + periods_today * secs
+    # Time.at((self.to_i/seconds).floor*seconds)
+  end
+  def end_of_period(secs=5.minutes)
+    return self if secs >= 1.day/2
+    beginning_of(secs) + secs - 1.second
+    # Time.at((self.to_i/seconds).floor*seconds+seconds)
+  end
+  
+  def upto(max, interval=1.day, inclusive=true)
+    t = self
+    while t < max || (inclusive && t <= max)
+      yield t
+      t += interval
+    end
+  end
+  
+protected
+  
+   def change(options)
+     self.class.send(
+       self.utc? ? :utc_time : :local_time,
+       options[:year]  || self.year,
+       options[:month] || self.month,
+       options[:day]   || self.day,
+       options[:hour]  || self.hour,
+       options[:min]   || (options[:hour] ? 0 : self.min),
+       options[:sec]   || ((options[:hour] || options[:min]) ? 0 : self.sec),
+       options[:usec]  || ((options[:hour] || options[:min] || options[:sec]) ? 0 : self.usec)
+     )
+  end
+  
+end

data/lib/time_layout.rb

@@ -0,0 +1,97 @@
+require File.dirname(__FILE__) + '/numeric'
+require File.dirname(__FILE__) + '/time_span'
+
+# assert interval is constant
+# assert start_at of one TimeSpan can equal end_at of another
+class TimeLayout
+  attr_accessor :key
+  attr_reader :time_spans
+  
+  DEFAULT_INTERVAL = 1.day
+  
+  # :time_spans or :start_at required
+  def initialize(args)
+    @key = args[:key]
+    if args[:time_spans] and args[:time_spans].is_a?(Array)
+      @time_spans = args[:time_spans]
+    else
+      @time_spans = []
+      if args[:end_at].nil? || args[:end_at].is_a?(Array) && args[:end_at].compact.empty?
+        @interval = calculate_interval_from_times(args[:start_at]) 
+        args[:end_at] = nil
+      end
+      args[:start_at].each_with_index do |start_at,i|
+        if args[:end_at]
+          @time_spans << TimeSpan.new(:start_at => start_at, :end_at => args[:end_at][i])
+        else
+          @time_spans << TimeSpan.new(:start_at => start_at, :duration => self.interval)
+        end
+      end
+    end
+  end
+  
+  def index_at(t)
+    @time_spans.each_with_index do |time_span,i|
+      return i if time_span.envelopes?(t, false)
+    end
+    # if t falls on the end of a time_span and not the start of any others
+    @time_spans.each_with_index do |time_span,i|
+      return i if time_span.envelopes?(t, true)
+    end
+    nil
+  end
+  
+  def indices_enveloping(time_span)
+    indices = []
+    weights = []
+    @time_spans.each_with_index do |ts,i|
+      if ts.overlaps?(time_span, false)
+        indices << i
+        weights << ts.overlap_by(time_span, false)
+      end
+    end
+    return indices, weights
+  end
+  
+  def [](i)
+    @time_spans[i] if (@time_spans && @time_spans.is_a?(Array) && i >= 0 && i < @time_spans.length)
+  end
+  
+  def start_at # of entire TimeLayout
+    @start_at ||= self.time_spans.inject(nil){|memo,time_span| (memo && memo < time_span.start_at) ? memo : time_span.start_at }
+  end
+  
+  def end_at # of entire TimeLayout
+    @end_at ||= self.time_spans.inject(nil){|memo,time_span| (memo && memo > time_span.end_at) ? memo : time_span.end_at }
+  end
+  
+  def interval
+    @interval ||= (@time_spans.first.duration || calculate_interval_from_time_spans)
+  end
+  
+  def length
+    @length ||= @time_spans.length
+  end
+  
+  def time_spans=(arr=[])
+    @interval = nil
+    @start_at = nil
+    @end_at   = nil
+    @time_spans = arr
+  end
+  
+  def duration
+    self.end_at - self.start_at
+  end
+  
+protected
+  
+  def calculate_interval_from_times(times=[])
+    times.length < 2 ? DEFAULT_INTERVAL : times[1] - times[0]
+  end
+  
+  def calculate_interval_from_time_spans
+    time_spans.length < 2 ? DEFAULT_INTERVAL : time_spans[1].start_at - time_spans[0].start_at
+  end
+  
+end

data/lib/time_span.rb

@@ -0,0 +1,59 @@
+require File.dirname(__FILE__) + '/numeric'
+
+class TimeSpan
+  attr_accessor :start_at, :end_at, :duration
+  
+  def initialize(args={})
+    @start_at = args[:start_at]
+    
+    if @end_at = args[:end_at]
+      @end_at, @start_at = @start_at, @end_at if @start_at > @end_at
+      @duration = @end_at - @start_at
+    elsif @duration = args[:duration]
+      @end_at = @start_at + @duration
+    end
+  end
+  
+  def first
+    @start_at
+  end
+  
+  def last
+    @end_at
+  end
+  
+  def envelopes?(t, include_end=true)
+    t >= @start_at && ( t < @end_at || (include_end && t <= @end_at) )
+  end
+  
+  # TODO
+  def enveloped_by?(args, include_end=true)
+    case
+    when args.is_a?(TimeSpan)
+    when args.is_a?(Range)
+    when args.is_a?(Array)
+    end
+  end
+  
+  def overlaps?(t, include_end=true)
+    if include_end
+      t.end_at >= @start_at && t.start_at <= @end_at
+    else
+      t.end_at > @start_at && t.start_at < @end_at
+    end
+  end
+  
+  # ratio: overlap/duration
+  def overlap_by(t, include_end=true)
+    self.overlap(t, include_end)/@duration.to_f
+  end
+  
+  def overlap(t, include_end=true)
+    return 0 unless self.overlaps?(t, include_end)
+    e = t.end_at > @end_at ? @end_at : t.end_at
+    s = t.start_at < @start_at ? @start_at : t.start_at
+    o = e-s
+    !include_end && o <= 1 ? 0.0 : o
+  end
+  
+end

data/lib/weather_parameter.rb

@@ -0,0 +1,68 @@
+require File.dirname(__FILE__) + '/numeric'
+require File.dirname(__FILE__) + '/time_layout'
+require File.dirname(__FILE__) + '/time_span'
+
+class WeatherParameter
+  attr_accessor :time_layout, :values, :calculation_method
+  
+  DEFAULT_CALCULATION_METHOD = :mean
+  
+  def initialize(args)
+    @time_layout  = args[:time_layout]
+    @values       = args[:values]
+    @calculation_method = args[:calculation_method] || DEFAULT_CALCULATION_METHOD
+  end
+  
+  def [](i)
+    @values[i] if (@values && @values.is_a?(Array) && i >= 0 && i < @values.length)
+  end
+  
+  def value_at(t)
+    if t.is_a?(TimeSpan)
+      self.send @calculation_method, t
+    else
+      self[@time_layout.index_at(t)]
+    end
+  end
+  
+protected
+  
+  def mean(t)
+    indices, weights = @time_layout.indices_enveloping(t)
+    return nil if indices.nil? || indices.empty?
+    values = indices.inject([]) {|memo,i| memo << @values[i]; memo }
+    sum = 0.0
+    values.each_with_index{|value,i| sum = sum + value * weights[i] }
+    total_weight = weights.inject{|total,w| total + w }
+    sum/total_weight
+  end
+  
+  def first(t)
+    indices, weights = @time_layout.indices_enveloping(t)
+    return nil if indices.nil? || indices.empty?
+    values[indices.first]
+  end
+  
+  def max(t)
+    indices, weights = @time_layout.indices_enveloping(t)
+    return nil if indices.nil? || indices.empty?
+    indices.map{|i| values[i] }.max
+  end
+  
+  # def min(t)
+  #   
+  # end
+  # 
+  # def median(t)
+  #   
+  # end
+  # 
+  # def mode(t)
+  #   
+  # end
+  # 
+  # def last(t)
+  #   
+  # end
+  
+end