@@ -1,4 +1,4 @@ -Copyright (c) 2009 Mark +Copyright (c) 2009 Mark G Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the LICENSE @@ -8,28 +8,43 @@ information, or they can be used in a hierarchical configuration where lower preferred weather services are only used if previous services are unavailable. +== version + +Version 0.1.0 is the current release of this gem. +The gem is available from github (attack-barometer) or rubyforge (barometer). +It is fully functional (for three weather service APIs). + == status Currently this project is in development and will only work for a few weather services (wunderground, google, yahoo). -Features to be added before first release: -- gem setup/config, apply to rubyforge - -Features to be added in future releases: +Features to be added next: - even more weather service drivers (noaa, weather.com, weatherbug) -- ability to query multiple services and combine/average the results -- support iaco as a query format = dependencies +=== Google API key + +In most cases you will need to have a free google geocode api key. +Get one here: http://code.google.com/apis/maps/signup.html +Then put it in the file '~/.barometer' by adding the line: +geocode_google: YOUR_KEY_HERE + +You will need this for: +- using the Barometer gem (unless you use queries that are directly supported + by the weather source API, ie yahoo will take a zip code directly and doesn't + require any geocoding) +- running the Barometer binary +- running the Barometer Web Demo + === HTTParty Why? HTTParty was created and designed specifically for consuming web services. I choose to use this over using the Net::HTTP library directly to allow for faster development of this project. -HTTParty is also extended to include configurable Timoout support. +HTTParty is also extended to include configurable Timeout support. === tzinfo @@ -96,6 +111,18 @@ You can use barometer from the command line. # barometer berlin This will output the weather information for the given query. +See the help for more command line information. + + # barometer -h + +=== web demo + +There is a Sinatra application that demos the functionality of Barometer, +and provides Barometer information. Start this local demo with: + + # barometer -w + +NOTE: This requires the gems "sinatra" and "vegas". === fail @@ -188,6 +215,25 @@ the data as shown in the above examples. puts weather.source(:wunderground).for(time).low.f +== averages + +If you consume more then one weather service, Barometer can provide averages +for the values (currently only for the 'current' values and not the forecasted +values). + + require 'barometer' + + Barometer.google_geocode_key = "THE_GOOGLE_API_KEY" + # use yahoo and wunderground + Barometer.selection = { 1 => [:yahoo, :wunderground] } + + barometer = Barometer.new("90210") + weather = barometer.measure + + puts weather.temperture + +This will calculate the average temperature as given by :yahoo and :wunderground + == simple answers After you have measured the data, Barometer provides several "simple answer" README.rdoc @@ -7,5 +7,4 @@ - Rdoc compatible documentation - Weather Service API key setting -- support IACO as a query format - store links from weather response \ No newline at end of file TODO @@ -1,63 +1,415 @@ #!/usr/bin/env ruby - -require File.dirname(__FILE__) + '/../lib/barometer' -#require 'rubygems' -#require 'attack-barometer' - -# TODO - -# set default Google Key ... maybe need a config file? -Barometer.google_geocode_key = "ABQIAAAAq8TH4offRcGrok8JVY_MyxRi_j0U6kJrkFvY4-OX2XYmEAa76BSFwMlSow1YgX8BOPUeve_shMG7xw" - -# take command line paramters -# service: --yahoo, --wunderground, --google -# units: -m --metric, -i --imperial -# geocode: -g --geocode (force geocode) -# timeout: -t 15 --timeout 15 -# skip: --skip (skip graticule) -# help: -h --help -# wet threshold: -w --wet -# windy threshold: -v --wind -# pop threshold: -p --pop -# time: -a --at - -# prettier output -# show simple answers -# more help -# error display (out of sources, etc.) - -if ARGV.size == 0 - puts 'Barometer [Powered by wunderground]' - puts 'USAGE: barometer [query]' - puts 'EXAMPLES:' - puts ' barometer paris' - exit + +# == Barometer +# This is the command line interface to the barometer gem. +# +# == Examples +# This command will measure the weather for the given query. +# barometer berlin +# +# Other examples: +# barometer --yahoo 90210 +# barometer --verbose 'new york' +# +# == Local Web Demo +# You can easily interact directly with barometer with the command: +# barometer -w +# +# This demo has 2 gem requirements: +# - sinatra (tested with 0.9.1.1) +# - vegas (tested with 0.0.1) +# +# == Usage +# barometer [options] query +# +# For help use: barometer -h +# +# Options: +# -v, --version Display the version, then exit +# -V, --verbose Verbose output +# -t, --timeout seconds until service queries will timeout +# -g, --geocode Force Geocoding of query +# -m, --metric measure in metric +# -i, --imperial measure in imperial +# --no-wunderground DONT use default wunderground as source +# --yahoo use yahoo as source +# --google use google as source +# -p, --pop pop threshold used to determine wet? +# -s, --wind wind speed threshold used to determine windy? +# -a, --at time/date used to determine when to calculate summary +# +# Web Demo: +# -w, --web run web-app with barometer demo +# -k, --kill stop the web demo background process +# -S, --status show the web demo status +# +# == Author +# Mark G +# http://github.com/attack/barometer +# +# == Copyright +# Copyright (c) 2009 Mark G. Licensed under the MIT License: +# http://www.opensource.org/licenses/mit-license.php + +require 'rubygems' +#require 'barometer' +require 'lib/barometer' + +require 'optparse' +require 'rdoc/usage' +require 'ostruct' +require 'time' +require 'date' +require 'yaml' + +# file where API keys are stored +KEY_FILE = File.expand_path(File.join('~', '.barometer')) + +class App + VERSION = '0.0.1' + + attr_reader :options + + def initialize(arguments, stdin) + @arguments = arguments.dup + + # Set defaults + @options = OpenStruct.new + @options.timeout = 15 + @options.geocode = false + @options.skip_graticule = false + @options.metric = true + @options.sources = [:wunderground] + @options.verbode = false + @options.web = false + @options.at = Time.now.utc + + # thresholds + @options.windy_m = 10 + @options.windy_i = 7 + @options.pop = 50 + end + + # Parse options, check arguments, then process the command + def run + if parsed_options? && arguments_valid? + puts "Start at #{DateTime.now}\n\n" if @options.verbose + output_options if @options.verbose # [Optional] + + process_arguments + process_command + + puts "\nFinished at #{DateTime.now}" if @options.verbose + else + output_usage + end + end + + protected + + # future options + # + # time: -a --at + # + def parsed_options? + # Specify options + opt = OptionParser.new + opt.on('-v', '--version') { output_version ; exit 0 } + opt.on('-h', '--help') { output_help } + opt.on('-V', '--verbose') { @options.verbose = true } + opt.on('-a n', '--at n') {|n| @options.at = Time.parse(n.to_s) } + opt.on('-t n', '--timeout n') {|n| @options.timeout = n } + opt.on('-w', '--web') { @options.web = true; ARGV.shift } + opt.on('-g', '--geocode') { @options.geocode = true } + opt.on('--skip') { @options.skip_graticule = true } + opt.on('-m', '--metric') { @options.metric = true } + opt.on('-i', '--imperial') { @options.metric = false } + opt.on('--no-wunderground') { @options.sources = @options.sources.delete_if{|s| s == :wunderground} } + opt.on('--yahoo') { @options.sources << :yahoo } + opt.on('--google') { @options.sources << :google } + opt.on('-p n', '--pop n') {|n| @options.pop = n.to_i || 50 } + opt.on('-s n', '--wind n') {|n| @options.metric ? @options.windy_m = n.to_f || 10 : @options.windy_i = n.to_f || 7 } + + # pass these onto vegas + opt.on('-k', '--kill') { @options.web = true } + opt.on('-S', '--status') { @options.web = true } + + opt.parse!(@arguments) rescue return false + + process_options + true + end + + # Performs post-parse processing on options + def process_options + Barometer.force_geocode = @options.geocode + Barometer.selection = { 1 => @options.sources.uniq } + Barometer.skip_graticule = @options.skip_graticule + Barometer.timeout = @options.timeout + end + + def output_options + puts "Options:\n" + + @options.marshal_dump.each do |name, val| + puts " #{name} = #{val}" + end + puts + end + + # True if required arguments were provided + def arguments_valid? + true if (@arguments.length >= 1 || @options.web) + end + + # Setup the arguments + def process_arguments + #puts @arguments.inspect + end + + def output_help + output_version + RDoc::usage() #exits app + end + + def output_usage + RDoc::usage('usage') # gets usage from comments above + end + + def output_version + puts "#{File.basename(__FILE__)} version #{VERSION}" + end + + def process_command + if @options.web + run_web_mode(@arguments.join(" ")) + else + barometer = Barometer.new(@arguments.join(" ")) + begin + barometer.measure(@options.metric) if barometer + pretty_output(barometer) if barometer.weather + rescue Barometer::OutOfSources + puts + puts " SORRY: your query did not provide any results" + puts + end + end + end end - -barometer = Barometer.new(ARGV[0]) -weather = barometer.measure(true) + +# +# HELPERS +# + +@level = 1 def y(value) value ? "yes" : "no" end -if weather - puts "###################################################" - puts "# #{weather.default.location.name}" - puts "#" - puts "# (lat: #{weather.default.location.latitude}, long: #{weather.default.location.longitude})" - puts "###################################################" - puts " -- CURRENT --" - puts " temperature: #{weather.now.temperature}" +def div(char="#") + puts char*50 +end + +def title(title, level=1) + @level = level + puts "#{" " * @level}-- #{title} --" +end + +def value(title, value) + puts "#{" " * @level}#{title}: #{value}" unless value.nil? +end + +def blank puts - puts " -- QUESTIONS --" - puts " day? : #{y(weather.day?)}" - puts " sunny?: #{y(weather.sunny?)}" - puts " windy?: #{y(weather.windy?)}" - puts " wet? : #{y(weather.wet?)}" +end + +def section(title, level=1, show_blank=true) + @level = level + title(title, level); yield; blank if show_blank +end + +def pretty_hash(hash) + return unless hash.is_a?(Hash) + hash.each { |k,v| value(k,v) } +end + +def pretty_summary(s) + return unless s + section("AVERAGES") do + pretty_hash({ + "humidity" => s.humidity.to_i, "temperature" => s.temperature }) + end + section("SUMMARY#{ " (@ #{@options.at})" if @options.at }") do + pretty_hash({ + "day?" => s.day?(@options.at), "sunny?" => s.sunny?(@options.at), + "windy?" => s.windy?(@options.metric ? @options.windy_m : @options.windy_i, @options.at), + "wet?" => s.wet?(@options.pop,@options.at) }) + end +end + +def pretty_query(q) + return unless q + section("QUERY", 2) do + pretty_hash({"Format" => q.format}) + pretty_hash({ + "Address" => q.geo.address, + "Locality" => q.geo.locality, "Region" => q.geo.region, + "Country" => q.geo.country, "Country Code" => q.geo.country_code, + "Latitude" => q.geo.latitude, "Longitude" => q.geo.longitude }) if q.geo + end +end + +def pretty_location(l) + return unless l + section("LOCATION", 2) do + pretty_hash({ + "ID" => l.id, "Name" => l.name, + "City" => l.city, "State Name" => l.state_name, + "State Code" => l.state_code, "Country" => l.country, + "Country Code" => l.country_code, "Zip Code" => l.zip_code, + "Latitude" => l.latitude, "Longitude" => l.longitude }) + end +end + +def pretty_station(s) + return unless s + section("STATION", 2) do + pretty_hash({ + "ID" => s.id, "Name" => s.name, + "City" => s.city, "State Name" => s.state_name, + "State Code" => s.state_code, "Country" => s.country, + "Country Code" => s.country_code, "Zip Code" => s.zip_code, + "Latitude" => s.latitude, "Longitude" => s.longitude }) + end +end + +def pretty_timezone(t) + return unless t + section("TIMEZONE", 2) do + pretty_hash({ "Long" => t.timezone, "Code" => t.code,"DST?" => t.dst? }) + end +end + +def pretty_current(c) + return unless c + section("CURRENT", 2) do + pretty_hash({ + "Time" => c.time, "Local Time" => c.local_time, + "Humidity" => c.humidity, "Icon" => c.icon, + "Condition" => c.condition, "Temperature" => c.temperature, + "Dew Point" => c.dew_point, "Heat Index" => c.heat_index, + "Pressure" => c.pressure, "Visibility" => c.visibility }) + pretty_hash({ "Wind Chill" => c.wind_chill, "Wind" => c.wind, + "Wind Direction" => c.wind.direction, "Degrees" => c.wind.degrees }) if c.wind + pretty_hash({ "Sun Rise" => c.sun.rise, "Sun Set" => c.sun.set }) if c.sun + end +end + +def pretty_forecast(f) + return unless f + section("FOR: #{f.date}", 3) do + pretty_hash({ + "Date" => f.date, "Icon" => f.icon, + "Condition" => f.condition, "High" => f.high, + "Low" => f.low, "POP" => f.pop }) + pretty_hash({ "Sun Rise" => f.sun.rise, "Sun Set" => f.sun.set }) if f.sun + end +end + +def pretty_forecasts(forecasts) + return unless forecasts + section("FORECAST", 3, false) do + blank + forecasts.each do |forecast| + pretty_forecast(forecast) + end + end +end + +def pretty_measurement(m) + return unless m + section(m.source.to_s, 1) do + pretty_hash({ + "Source" => m.source, "Time" => m.time, + "Metric" => m.metric?, "Success" => m.success? }) + end + pretty_location(m.location) + pretty_station(m.station) + pretty_timezone(m.timezone) + pretty_current(m.current) + pretty_forecasts(m.forecast) +end + +def pretty_measurements(w) + return unless w + section("MEASUREMENTS", 1) do + blank + w.measurements.each do |m| + pretty_measurement(m) + end + end +end + +def pretty_info + title("INFO", 1) + value("GitHub", "http://github.com/attack/barometer") +end + +def pretty_output(barometer) + weather = barometer.weather + if weather + div + puts "#" + puts "# #{weather.default.location.name || barometer.query.q}" + puts "#" + div + blank + pretty_summary(weather) + pretty_query(barometer.query) + pretty_measurements(weather) + pretty_info + div("-") + end +end + +def run_web_mode(query=nil) + + raise "This is currently disabled" + + #require File.expand_path(File.dirname(__FILE__) + '/../lib/webometer/webometer.rb') + #require 'vegas' + + #Vegas::Runner.new(Webometer, 'webometer') do |opts, app| + # opts is an option parser object + # app is your app class + #end +end + +def geocode_google_key_message puts + puts "Please update the key_file '#{KEY_FILE}' with your google api key" + puts "Get it here: http://code.google.com/apis/maps/signup.html" + puts "The, add this line to the file:" + puts "geocode_google: YOUR_KEY_KERE" puts - puts " -- INFO --" - puts " http://github.com/attack/barometer" - puts "---------------------------------------------------" -end \ No newline at end of file +end + +# set API keys +if File.exists?(KEY_FILE) + keys = YAML.load_file(KEY_FILE) + if keys["geocode_google"] + Barometer.google_geocode_key = keys["geocode_google"] + else + geocode_google_key_message + exit + end +else + File.open(KEY_FILE, 'w') {|f| f << "geocode_google: YOUR_KEY_KERE" } + geocode_google_key_message + exit +end + +# Create and run the application +app = App.new(ARGV, STDIN) +app.run bin/barometer @@ -8,7 +8,7 @@ module Barometer class Geo attr_accessor :latitude, :longitude - attr_accessor :locality, :region, :country, :country_code + attr_accessor :locality, :region, :country, :country_code, :address # # this will take a Location object (either generated by Graticule @@ -60,6 +60,7 @@ module Barometer @region = location.region @country = location.country @country_code = location.country_code + @address = location.address_line end def build_from_httparty(location=nil) @@ -87,6 +88,7 @@ module Barometer end @country = placemark["AddressDetails"]["Country"]["CountryName"] @country_code = placemark["AddressDetails"]["Country"]["CountryNameCode"] + @address = placemark["AddressDetails"]["Country"]["AddressLine"] end end lib/barometer/data/geo.rb @@ -1,10 +1,10 @@ module Graticule class Location - attr_accessor :country_code + attr_accessor :country_code, :address_line def attributes - [:latitude, :longitude, :street, :locality, :region, :postal_code, :country, :precision, :cuntry_code].inject({}) do |result,attr| + [:latitude, :longitude, :street, :locality, :region, :postal_code, :country, :precision, :cuntry_code, :address_line].inject({}) do |result,attr| result[attr] = self.send(attr) unless self.send(attr).blank? result end @@ -39,6 +39,7 @@ module Graticule l.postal_code = value(address.elements['.//PostalCodeNumber/text()']) l.country = value(address.elements['.//CountryName/text()']) l.country_code = value(address.elements['.//CountryNameCode/text()']) + l.address_line = value(address.elements['.//AddressLine/text()']) l.precision = PRECISION[address.attribute('Accuracy').value.to_i] || :unknown end end lib/barometer/extensions/graticule.rb @@ -31,20 +31,23 @@ module Barometer self.analyze! end - # analyze the saved query to determine the format. for the format of - # :zipcode and :postalcode the country_code can also be set + # analyze the saved query to determine the format. 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 end - @country_code = Barometer::Query.format_to_country_code(@format) end # take a list of acceptable (and ordered by preference) formats and convert @@ -93,6 +96,7 @@ module Barometer 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}$)/ @@ -112,12 +116,25 @@ module Barometer 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 + # accepts- :zipcode, :postalcode, :geocode, :icao # returns- :coordinates # if the conversion fails, return nil def self.to_coordinates(query, format) @@ -129,7 +146,7 @@ module Barometer end # this will take all query formats and convert them to coorinates - # accepts- :zipcode, :postalcode, :coordinates + # accepts- :zipcode, :postalcode, :coordinates, :icao # returns- :geocode def self.to_geocode(query, format) perform_geocode = false @@ -143,8 +160,17 @@ module Barometer if perform_geocode geo = self.geocode(query, country_code) country_code ||= geo.country_code if geo - return nil unless geo && geo.locality && geo.region && geo.country - return ["#{geo.locality}, #{geo.region}, #{geo.country}", country_code, 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}" + else + return nil unless geo && geo.locality && geo.region && geo.country + q = "#{geo.locality}, #{geo.region}, #{geo.country}" + 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 @@ -207,7 +233,6 @@ module Barometer }, :format => :xml )['kml']['Response'] - #puts location.inspect geo = Barometer::Geo.new(location) end @@ -223,6 +248,30 @@ module Barometer end country_code 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 lib/barometer/query.rb @@ -39,7 +39,7 @@ module Barometer class Wunderground < Service def self.accepted_formats - [:zipcode, :postalcode, :coordinates, :geocode] + [:zipcode, :postalcode, :icao, :coordinates, :geocode] end def self.source_name @@ -48,8 +48,9 @@ module Barometer # these are the icon codes that indicate "wet", used by wet? function def self.wet_icon_codes - %w(flurries rain sleet snow tstorms nt_flurries nt_rain nt_sleet nt_snow nt_tstorms) + %w(flurries rain sleet snow tstorms nt_flurries nt_rain nt_sleet nt_snow nt_tstorms chancerain) end + # these are the icon codes that indicate "sun", used by sunny? function def self.sunny_icon_codes %w(clear mostlysunny partlysunny sunny partlycloudy) end lib/barometer/services/wunderground.rb @@ -34,17 +34,9 @@ module Barometer # Quick access methods # - def current - (default = self.default) ? default.current : nil - end - - def forecast - (default = self.default) ? default.forecast : nil - end - - def now - self.current - end + def current; (default = self.default) ? default.current : nil; end + def forecast; (default = self.default) ? default.forecast : nil; end + def now; self.current; end def today default = self.default @@ -72,37 +64,48 @@ module Barometer # averages # - # average of all humidity values - # def humidity - # end - # - # # average of all temperature values - # def temperature - # end - # - # # average of all wind speed values - # def wind - # end - # - # # average of all pressure values - # def pressure - # end - # - # # average of all dew_point values - # def dew_point - # end - # - # # average of all heat_index values - # def heat_index - # end - # - # # average of all wind_chill values - # def wind_chill - # end - # - # # average of all visibility values - # def visibility - # end + # TODO: not tested (except via averages) + def metric? + self.default ? self.default.metric? : true + end + + # TODO: not tested (except via averages) + # 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 + def current_average(value_name) + values = [] + @measurements.each do |measurement| + values << measurement.current.send(value_name).to_f if measurement.success? + end + return nil unless values && values.size > 0 + values.inject(0.0) { |sum,v| sum += v } / values.size + end + + # TODO: not tested (except via averages) + 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 << self.current_average(value_name) + else + avg = self.now.send(value_name) + end + else + avg = (do_average ? self.current_average(value_name) : self.now.send(value_name)) + end + avg + 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 + def pressure(do_average=true); average("pressure",do_average,"Pressure"); end + def dew_point(do_average=true); average("dew_point",do_average,"Temperature"); end + def heat_index(do_average=true); average("heat_index",do_average,"Temperature"); end + def wind_chill(do_average=true); average("wind_chill",do_average,"Temperature"); end + def visibility(do_average=true); average("visibility",do_average,"Distance"); end # # quick access methods lib/barometer/weather.rb @@ -4,7 +4,7 @@ describe "Barometer" do before(:each) do @preference_hash = { 1 => [:wunderground] } - @key = "ABQIAAAAq8TH4offRcGrok8JVY_MyxRi_j0U6kJrkFvY4-OX2XYmEAa76BSFwMlSow1YgX8BOPUeve_shMG7xw" + @key = KEY end describe "and class methods" do spec/barometer_spec.rb @@ -35,6 +35,10 @@ describe "Geo" do @geo.country.should be_nil end + it "responds to address" do + @geo.address.should be_nil + end + it "responds to coordinates" do @geo.longitude = "99.99" @geo.latitude = "88.88" spec/data_geo_spec.rb @@ -7,6 +7,7 @@ describe "Query" do @postal_code = "T5B 4M9" @coordinates = "40.756054,-73.986951" @geocode = "New York, NY" + @icao = "KSFO" # actual conversions @zipcode_to_coordinates = "34.1030032,-118.4104684" @@ -26,18 +27,28 @@ describe "Query" do Barometer::Query.is_us_zipcode?(@zipcode).should be_true Barometer::Query.is_us_zipcode?(@postal_code).should be_false Barometer::Query.is_us_zipcode?(@coordinates).should be_false + Barometer::Query.is_coordinates?(@icao).should be_false end it "detects a postalcode" do Barometer::Query.is_canadian_postcode?(@postal_code).should be_true Barometer::Query.is_canadian_postcode?(@zipcode).should be_false Barometer::Query.is_canadian_postcode?(@coordinates).should be_false + Barometer::Query.is_coordinates?(@icao).should be_false end it "detects a coordinates" do Barometer::Query.is_coordinates?(@coordinates).should be_true Barometer::Query.is_coordinates?(@zipcode).should be_false Barometer::Query.is_coordinates?(@postal_code).should be_false + Barometer::Query.is_coordinates?(@icao).should be_false + end + + it "detects an ICAO" do + Barometer::Query.is_icao?(@coordinates).should be_false + Barometer::Query.is_icao?(@zipcode).should be_false + Barometer::Query.is_icao?(@postal_code).should be_false + Barometer::Query.is_icao?(@icao).should be_true end end @@ -58,6 +69,7 @@ describe "Query" do @query.country_code.should == "US" @query.zipcode?.should be_true @query.postalcode?.should be_false + @query.icao?.should be_false @query.coordinates?.should be_false @query.geocode?.should be_false end @@ -71,6 +83,21 @@ describe "Query" do @query.country_code.should == "CA" @query.zipcode?.should be_false @query.postalcode?.should be_true + @query.icao?.should be_false + @query.coordinates?.should be_false + @query.geocode?.should be_false + end + + it "recognizes icao" do + @query.q = @icao + @query.format.should be_nil + @query.analyze! + @query.format.to_sym.should == :icao + + @query.country_code.should be_nil + @query.zipcode?.should be_false + @query.postalcode?.should be_false + @query.icao?.should be_true @query.coordinates?.should be_false @query.geocode?.should be_false end @@ -84,6 +111,7 @@ describe "Query" do @query.country_code.should be_nil @query.zipcode?.should be_false @query.postalcode?.should be_false + @query.icao?.should be_false @query.coordinates?.should be_true @query.geocode?.should be_false end @@ -97,6 +125,7 @@ describe "Query" do @query.country_code.should be_nil @query.zipcode?.should be_false @query.postalcode?.should be_false + @query.icao?.should be_false @query.coordinates?.should be_false @query.geocode?.should be_true end @@ -168,7 +197,7 @@ describe "Query" do describe "when converting queries" do before(:each) do - @key = "ABQIAAAAq8TH4offRcGrok8JVY_MyxRi_j0U6kJrkFvY4-OX2XYmEAa76BSFwMlSow1YgX8BOPUeve_shMG7xw" + @key = KEY url_start = "http://maps.google.com/maps/geo?" # # for Graticule and/or HTTParty geocoding @@ -221,6 +250,13 @@ describe "Query" do 'geocode_40_73.xml') ) ) + FakeWeb.register_uri(:get, + "#{url_start}output=xml&q=KSFO&gl=&key=#{@key}", + :string => File.read(File.join(File.dirname(__FILE__), + 'fixtures', + 'geocode_ksfo.xml') + ) + ) end describe "to coordinates," do @@ -253,6 +289,10 @@ describe "Query" do Barometer::Query.to_coordinates(@postal_code, :postalcode).first.should == "53.570447,-113.456083" end + it "converts from icao" do + Barometer::Query.to_coordinates(@icao, :icao).first.should == "37.615223,-122.389979" + end + end describe "to geocode" do @@ -275,6 +315,10 @@ describe "Query" do Barometer::Query.to_geocode(@postal_code, :postalcode).first.should == @postal_code end + it "converts from icao" do + Barometer::Query.to_geocode(@icao, :icao).first.should == "San Francisco Airport, USA" + end + end describe "when Graticule disabled," do @@ -357,7 +401,7 @@ describe "Query" do before(:each) do @query = Barometer::Query.new(@zipcode) - Barometer::Query.google_geocode_key = "ABQIAAAAq8TH4offRcGrok8JVY_MyxRi_j0U6kJrkFvY4-OX2XYmEAa76BSFwMlSow1YgX8BOPUeve_shMG7xw" + Barometer::Query.google_geocode_key = KEY end it "converts to coordinates" do @@ -384,7 +428,7 @@ describe "Query" do before(:each) do @query = Barometer::Query.new(@postal_code) - Barometer::Query.google_geocode_key = "ABQIAAAAq8TH4offRcGrok8JVY_MyxRi_j0U6kJrkFvY4-OX2XYmEAa76BSFwMlSow1YgX8BOPUeve_shMG7xw" + Barometer::Query.google_geocode_key = KEY end it "converts to coordinates" do @@ -411,7 +455,7 @@ describe "Query" do before(:each) do @query = Barometer::Query.new(@geocode) - Barometer::Query.google_geocode_key = "ABQIAAAAq8TH4offRcGrok8JVY_MyxRi_j0U6kJrkFvY4-OX2XYmEAa76BSFwMlSow1YgX8BOPUeve_shMG7xw" + Barometer::Query.google_geocode_key = KEY end it "converts to coordinates" do @@ -438,7 +482,7 @@ describe "Query" do before(:each) do @query = Barometer::Query.new(@coordinates) - Barometer::Query.google_geocode_key = "ABQIAAAAq8TH4offRcGrok8JVY_MyxRi_j0U6kJrkFvY4-OX2XYmEAa76BSFwMlSow1YgX8BOPUeve_shMG7xw" + Barometer::Query.google_geocode_key = KEY end it "converts to geocode" do spec/query_spec.rb @@ -3,7 +3,7 @@ require 'spec_helper' describe "Wunderground" do before(:each) do - @accepted_formats = [:zipcode, :postalcode, :coordinates, :geocode] + @accepted_formats = [:zipcode, :postalcode, :icao, :coordinates, :geocode] @base_uri = "http://api.wunderground.com/auto/wui/geo" end spec/service_wunderground_spec.rb @@ -2,6 +2,7 @@ require 'rubygems' require 'spec' require 'fakeweb' require 'cgi' +require 'yaml' $LOAD_PATH.unshift(File.dirname(__FILE__)) $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib')) @@ -9,6 +10,30 @@ require 'barometer' FakeWeb.allow_net_connect = false +KEY_FILE = File.expand_path(File.join('~', '.barometer')) + +def geocode_google_key_message + puts + puts "Please update the key_file '#{KEY_FILE}' with your google api key" + puts "example:" + puts "geocode_google: YOUR_KEY_KERE" + puts +end + +if File.exists?(KEY_FILE) + keys = YAML.load_file(KEY_FILE) + if keys["geocode_google"] + KEY = keys["geocode_google"] + else + geocode_google_key_message + exit + end +else + File.open(KEY_FILE, 'w') {|f| f << "geocode_google: YOUR_KEY_KERE" } + geocode_google_key_message + exit +end + Spec::Runner.configure do |config| end spec/spec_helper.rb @@ -78,6 +78,174 @@ describe "Weather" do end + describe "when calculating averages" do + + before(:each) do + @weather = Barometer::Weather.new + @wunderground = Barometer::Measurement.new(:wunderground) + @wunderground.current = Barometer::CurrentMeasurement.new + @wunderground.success = true + @yahoo = Barometer::Measurement.new(:yahoo) + @yahoo.current = Barometer::CurrentMeasurement.new + @yahoo.success = true + @google = Barometer::Measurement.new(:google) + @weather.measurements << @wunderground + @weather.measurements << @yahoo + @weather.measurements << @google + end + + describe "for temperature" do + + before(:each) do + @weather.source(:wunderground).current.temperature = Barometer::Temperature.new + @weather.source(:wunderground).current.temperature.c = 10 + @weather.source(:yahoo).current.temperature = Barometer::Temperature.new + @weather.source(:yahoo).current.temperature.c = 6 + end + + it "returns averages" do + @weather.temperature.c.should == 8 + end + + it "returns default when disabled" do + @weather.temperature(false).c.should == 10 + end + + end + + describe "for wind" do + + before(:each) do + @weather.source(:wunderground).current.wind = Barometer::Speed.new + @weather.source(:wunderground).current.wind.kph = 10 + @weather.source(:yahoo).current.wind = Barometer::Speed.new + @weather.source(:yahoo).current.wind.kph = 6 + end + + it "returns averages" do + @weather.wind.kph.should == 8 + end + + it "returns default when disabled" do + @weather.wind(false).kph.should == 10 + end + + end + + describe "for humidity" do + + before(:each) do + @weather.source(:wunderground).current.humidity = 10 + @weather.source(:yahoo).current.humidity = 6 + end + + it "returns averages" do + @weather.humidity.should == 8 + end + + it "returns default when disabled" do + @weather.humidity(false).should == 10 + end + + end + + describe "for pressure" do + + before(:each) do + @weather.source(:wunderground).current.pressure = Barometer::Pressure.new + @weather.source(:wunderground).current.pressure.mb = 10 + @weather.source(:yahoo).current.pressure = Barometer::Pressure.new + @weather.source(:yahoo).current.pressure.mb = 6 + end + + it "returns averages" do + @weather.pressure.mb.should == 8 + end + + it "returns default when disabled" do + @weather.pressure(false).mb.should == 10 + end + + end + + describe "for dew_point" do + + before(:each) do + @weather.source(:wunderground).current.dew_point = Barometer::Temperature.new + @weather.source(:wunderground).current.dew_point.c = 10 + @weather.source(:yahoo).current.dew_point = Barometer::Temperature.new + @weather.source(:yahoo).current.dew_point.c = 6 + end + + it "returns averages" do + @weather.dew_point.c.should == 8 + end + + it "returns default when disabled" do + @weather.dew_point(false).c.should == 10 + end + + end + + describe "for heat_index" do + + before(:each) do + @weather.source(:wunderground).current.heat_index = Barometer::Temperature.new + @weather.source(:wunderground).current.heat_index.c = 10 + @weather.source(:yahoo).current.heat_index = Barometer::Temperature.new + @weather.source(:yahoo).current.heat_index.c = 6 + end + + it "returns averages" do + @weather.heat_index.c.should == 8 + end + + it "returns default when disabled" do + @weather.heat_index(false).c.should == 10 + end + + end + + describe "for wind_chill" do + + before(:each) do + @weather.source(:wunderground).current.wind_chill = Barometer::Temperature.new + @weather.source(:wunderground).current.wind_chill.c = 10 + @weather.source(:yahoo).current.wind_chill = Barometer::Temperature.new + @weather.source(:yahoo).current.wind_chill.c = 6 + end + + it "returns averages" do + @weather.wind_chill.c.should == 8 + end + + it "returns default when disabled" do + @weather.wind_chill(false).c.should == 10 + end + + end + + describe "for visibility" do + + before(:each) do + @weather.source(:wunderground).current.visibility = Barometer::Distance.new + @weather.source(:wunderground).current.visibility.km = 10 + @weather.source(:yahoo).current.visibility = Barometer::Distance.new + @weather.source(:yahoo).current.visibility.km = 6 + end + + it "returns averages" do + @weather.visibility.km.should == 8 + end + + it "returns default when disabled" do + @weather.visibility(false).km.should == 10 + end + + end + + end + describe "when answering the simple questions," do before(:each) do spec/weather_spec.rb 4624cc51299cf5356698d65a7a29eeafbb4f927a Mark rtec88@gmail.com http://github.com/attack/barometer/commit/4ed4222ea098d7b5e6f58c2efa6a860c073556f5 4ed4222ea098d7b5e6f58c2efa6a860c073556f5 2009-05-02T17:27:52-07:00 2009-05-02T17:27:52-07:00 improve barometer binary, add config file support, update readme 5271fb4e8f173c620044becd392107868240359d Mark rtec88@gmail.com