forecast 0.0.7 → 0.0.8

data/lib/forecast/adapters/yahoo_adapter.rb

@@ -11,21 +11,13 @@ class Forecast
         forecast = nil
         doc = get_rss(latitude, longitude)
         if doc
-          forecast = Forecast.new
+          hash = {}
           doc.elements.each('rss/channel/item/yweather:condition') do |elem|
             elem.attributes.each() do |attr|
-              name = attr[0]
-              value = attr[1]
-              case name
-                when 'date'
-                  forecast.date = DateTime.parse(value)
-                when 'temp'
-                  forecast.temp = value.to_i
-                when 'text'
-                  forecast.condition = get_condition(value)
-              end
+              hash[attr[0].to_sym] = attr[1]
             end
           end
+          forecast = get_forecast({latitude: latitude, longitude: longitude}.merge(hash))
         end
         return forecast
       end
@@ -40,24 +32,11 @@ class Forecast
         forecasts = Forecast::Collection.new
         if doc
           doc.elements.each('rss/channel/item/yweather:forecast') do |elem|
-            forecast = Forecast.new
+            hash = {}
             elem.attributes.each() do |attr|
-              puts 'attr' + attr.to_s
-              name = attr[0]
-              value = attr[1]
-              case name
-                when 'date'
-                  forecast.date = DateTime.parse(value)
-                when 'low'
-                  forecast.temp_min = get_temp(value)
-                when 'high'
-                  forecast.temp_max = get_temp(value)
-                when 'text'
-                  forecast.condition = get_condition(value)
-              end
+              hash[attr[0].to_sym] = attr[1]
             end
-            forecast.temp = (forecast.temp_min + forecast.temp_max) / 2
-            forecasts << forecast
+            forecasts << get_forecast({latitude: latitude, longitude: longitude}.merge(hash))
           end
         end
         return forecasts
@@ -69,7 +48,7 @@ class Forecast
           woeid = nil
           query = "SELECT * FROM geo.placefinder WHERE text='#{latitude}, #{longitude}' and gflags='R'"
           url = URL_YQL + "?q=" + URI::encode(query)
-          doc = get_doc(url)
+          doc = get_dom(url)
           doc.elements.each('query/results/Result/woeid') do |elem|
             woeid = elem.text
           end
@@ -79,12 +58,25 @@ class Forecast
         def get_rss(latitude, longitude)
           woeid = get_woeid(latitude, longitude)
           if woeid
-            doc = get_doc(URL_RSS, {w: woeid})
+            doc = Forecast::Utils.get_doc(URL_RSS, {w: woeid})
             return doc
           end
           return nil
         end
         
+        def get_forecast(hash)
+          forecast = Forecast.new
+          forecast.latitude = hash[:latitude]
+          forecast.longitude = hash[:longitude]
+          forecast.time = get_time(hash[:date])
+          forecast.condition = get_condition(hash[:text])
+          forecast.text = get_text(hash[:text])
+          forecast.temperature_min = get_temperature(hash[:low])
+          forecast.temperature_max = get_temperature(hash[:high])
+          forecast.temperature = get_temperature(hash.has_key?(:temp) ? hash[:temp] : [hash[:low], hash[:high]])
+          return forecast
+        end
+        
     end
   end
 end

data/lib/forecast/collection.rb

@@ -1,15 +1,15 @@
 class Forecast
   class Collection < Array
-    def select_date(date)
+    def select_time(time)
       result = nil
       date_forecasts = self.select do |obj|
-        obj.date.to_date == date.to_date
+        obj.time.to_date == time.to_date
       end
       if date_forecasts.length == 0
         return nil
       else
         hour_forecasts = date_forecasts.select do |obj|
-          obj.date.hour == obj.date.hour
+          obj.time.hour == obj.time.hour
         end
         if hour_forecasts.length > 0
           return hour_forecasts.first
@@ -17,10 +17,10 @@ class Forecast
         return date_forecasts.first
       end
       return nil
-      
     end
     
     private 
+      # Unused
       def seconds_between(date1, date2)
         ((Time.parse(date1.to_s) - Time.parse(date2.to_s)) / 3600).abs
       end

data/lib/forecast/conditions.yml

@@ -1,5 +1,5 @@
 forecast:
-  conditions: 
+  conditions:
     100: 'Clear'
     200: 'Partly Cloudy'
     210: 'Cloudy'
@@ -9,4 +9,4 @@ forecast:
     320: 'Heavy Rain'
     400: 'Light Snow'
     410: 'Snow'
-    500: 'Thunderstorm'
+    501: 'Storm'

data/lib/forecast/config.rb

@@ -1,13 +1,13 @@
+require "yaml"
 class Forecast
   class Config
       
-    attr_accessor :adapters, :provider, :temp_scale, :conditions, :cache, :themes, :theme, :config_file
+    attr_accessor :adapters, :provider, :scale, :conditions, :synonyms, :cache, :themes, :theme, :config_file
     
     def initialize
       
       @config_file = nil 
-      #File.dirname(File.dirname(File.dirname(__FILE__))) + "/config/forecast.yml"
-      
+      @provider||= :open_weather_map
       self.load(File.dirname(__FILE__) + '/**/*.yml')
       
       def theme
@@ -21,11 +21,10 @@ class Forecast
         end
         return @theme
       end
-      
     end
     
+    
     def load(pattern)
-      # puts 'load forecast pattern ' + pattern.to_s
       Dir.glob(pattern).sort{ |a, b| a.split(/\//).length <=> b.split(/\//).length}.reverse.each do |f|
         obj = YAML.load_file(f)
         # puts 'load forecast config ' + f.to_s

data/lib/forecast/config.yml

@@ -1,6 +1,4 @@
 forecast: 
-  provider: 
-    adapter: open_weather_map
+  provider: open_weather_map
   theme: weather_icons
-  temp_scale: fahrenheit
-  cache: false
+  scale: celsius

data/lib/forecast/http.rb

@@ -0,0 +1,80 @@
+require 'net/http'
+require 'rexml/document'
+require 'open-uri'
+require 'json'
+require "redis"
+
+class Forecast
+  
+  class Http
+    
+    def initialize(options = {})
+      @options = {cache: nil}.merge options
+      if @options[:cache]
+        cache_options = @options[:cache].merge({
+          host: "127.0.0.1", 
+          port: "6379"
+        })
+        if cache_options.has_key?(:url)
+          url = cache_options[:url]
+          uri = URI.parse(url)
+          #puts "Connecting to redis with url #{url}..."
+          @cache = Redis.new(host: uri.host, port: uri.port, password: uri.password)
+        elsif host != nil && port != nil
+          #puts "Connecting to redis on host #{host} at port #{port}..."
+          @cache = Redis.new(host: cache_options[:host], port: cache_options[:port])
+        end
+      end
+    end
+    
+    def get(url, params = {})
+      if @cache && (!@options[:cache].has_key?(:invalidate) || !@options[:cache][:invalidate])
+        key = get_key(url)
+        data = @cache.get(key)
+        if data
+          #puts 'Read from cache... ' + url
+          return data
+        end
+      end
+      if params.keys.count > 0
+        query_string = URI.encode_www_form(params)
+        url = url + "?" + query_string
+      end
+      #puts 'Get url... ' + url
+      resp = Net::HTTP.get_response(URI.parse(url))
+      data = resp.body
+      if data
+        if @cache
+          #puts 'Write to cache... ' + url
+          key = get_key(url)
+          @cache.set(key, data)
+          if @options[:cache] && @options[:cache].has_key?(:expire)
+            @cache.expire(key, @options[:cache][:expire])
+          end
+        end
+        return data
+      end
+    end
+    
+    def get_json(url, params = {})
+      data = get(url, params)
+      if data != nil
+        return JSON.parse(data)
+      end
+    end
+    
+    def get_dom(url, params = {})
+      data = get(url, params)
+      if data != nil
+        return REXML::Document.new(data)
+      end
+    end
+    
+    
+    private 
+      def get_key(url)
+        "Forecast::Http::" + url
+      end
+    
+  end
+end

data/lib/forecast/synonyms.yml

@@ -0,0 +1,32 @@
+forecast:
+  synonyms:
+    -
+      - 'Clear'
+      - 'Sunny'
+      - 'Sunshine'
+      - 'No Clouds'
+      - 'Fair'
+      - 'Breezy'
+    -
+      - 'Light Rain'
+      - 'Drizzle'
+      - 'Light showers'
+    -
+      - 'Rain'
+      - 'Showers'
+    -
+      - 'Heavy Rain'
+      - 'Thundershowers'
+    -
+      - 'Partly Cloudy'
+      - 'Clouds Sun'
+      - 'Fog Sun'
+      - 'Few Clouds'
+    -
+      - 'Overcast'
+      - 'Cloudy'
+      - 'Clouds'
+    -
+      - 'Storm'
+      - 'Thunderstorm'
+      - 'Blizzard'

data/lib/forecast/themes/weather_icons.yml

@@ -1,10 +1,12 @@
 forecast: 
   themes: 
-    weather_icons: 
-      Clear: "wi wi-day-sunny"
-      Partly Cloudy: "wi wi-day-sunny-overcast"
-      Cloudy: "wi wi-day-cloudy"
-      Mostly Cloudy: "wi wi-cloudy"
-      Light Rain: "wi wi-showers"
-      Rain: "wi wi-rain"
-      Heavy Rain: "wi wi-rain"
+    weather_icons:
+      prefix: 'wi wi-'
+      conditions:
+        Clear: "day-sunny"
+        Partly Cloudy: "sunny-overcast"
+        Cloudy: "day-cloudy"
+        Mostly Cloudy: "cloudy"
+        Light Rain: "showers"
+        Rain: "rain"
+        Heavy Rain: "rain"

data/lib/forecast/utils.rb

@@ -7,9 +7,50 @@ class Forecast
   module Utils
     class << self
       
-      def get_json(url, params)
-        query_string = URI.encode_www_form(params)
-        url = url + "?" + query_string
+      
+      def underscore(string)
+        if string.is_a?(String)
+          return string.gsub(/::/, '/').
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+          tr("-", "_").
+          downcase
+        elsif string.is_a?(Hash)
+          return Hash[string.map { |k, v| [Forecast::Utils.underscore(k.to_s).to_sym, v.is_a?(Hash) ? Forecast::Utils.underscore(v) : v] }]
+        else
+          string
+        end
+      end
+      
+      def fahrenheit_to_kelvin(fahrenheit)
+        ((fahrenheit - 32) / 1.8) - 273.15
+      end
+      
+      def fahrenheit_to_celsius(fahrenheit)
+        ((fahrenheit - 32) / 1.8)
+      end
+      
+      def kelvin_to_fahrenheit(kelvin)
+        return ((kelvin - 273.15) * 1.8 + 32)
+      end
+      
+      def kelvin_to_celsius(kelvin)
+        kelvin - 273.15
+      end
+      
+      def celsius_to_fahrenheit(celsius)
+        celsius * 1.8 + 32 
+      end
+      
+      def celsius_to_kelvin(celsius)
+        celsius + 273.15
+      end
+      
+      def get_json(url, params = {})
+        if params.keys.count > 0
+          query_string = URI.encode_www_form(params)
+          url = url + "?" + query_string
+        end
         resp = Net::HTTP.get_response(URI.parse(url))
         data = resp.body
         result = JSON.parse(data)
@@ -19,14 +60,68 @@ class Forecast
         return nil
       end
       
-      def get_doc(url, params)
-        query_string = URI.encode_www_form(params)
-        url = url + "?" + query_string
+      def get_doc(url, params = {})
+        if params.keys.count > 0
+          query_string = URI.encode_www_form(params)
+          url = url + "?" + query_string
+        end
         xml_data = Net::HTTP.get_response(URI.parse(url)).body
         doc = REXML::Document.new(xml_data)
         return doc
       end
       
+      def word_similarity(first, second)
+        
+        if !first.is_a?(String) || !second.is_a?(String)
+          return 0
+        end
+        similar_words = 0.0
+        first_words = first.downcase.split(/\W+/)
+        second_words = second.downcase.split(/\W+/)
+        
+        first_words.each do |first_word|
+          second_words.each do |second_word|
+            similar = 0.0
+            if first_word == second_word
+              similar = 1.0
+            else
+              l1 = levenshtein(first_word, second_word)
+              l = 1 - (l1.to_f / ([first_word.length, second_word.length].max))
+              l = [0, similar].max
+              l = [similar, 1].min
+              if l1 > 0.6
+                similar = 0.1
+              end
+            end
+            similar_words+= similar
+          end
+        end
+        count = first_words.concat(second_words).uniq.length
+        similarity = similar_words / count
+        return similarity
+      end
+      
+      def levenshtein(first, second)
+        matrix = [(0..first.length).to_a]
+        (1..second.length).each do |j|
+          matrix << [j] + [0] * (first.length)
+        end
+        (1..second.length).each do |i|
+          (1..first.length).each do |j|
+            if first[j-1] == second[i-1]
+              matrix[i][j] = matrix[i-1][j-1]
+            else
+              matrix[i][j] = [
+                matrix[i-1][j],
+                matrix[i][j-1],
+                matrix[i-1][j-1],
+              ].min + 1
+            end
+          end
+        end
+        return matrix.last.last
+      end
+      
     end
   end
 end

data/lib/forecast/version.rb

@@ -1,3 +1,3 @@
 class Forecast
-  VERSION = "0.0.7"
+  VERSION = "0.0.8"
 end

data/lib/forecast.rb

@@ -1,141 +1,73 @@
+require 'ostruct'
 require "forecast/version"
 require "forecast/config"
-require "forecast/model"
+require "forecast/utils"
 require "forecast/collection"
 require "forecast/adapter"
 require "forecast/adapters/yahoo_adapter"
 require "forecast/adapters/open_weather_map_adapter"
 require "forecast/adapters/wunderground_adapter"
-require "yaml"
-require "redis"
+require "forecast/adapters/forecast_io_adapter"
+require "forecast/http"
 
 class Forecast
   
-  # instance
+  PROVIDERS = Dir.glob(File.expand_path(File.dirname(__FILE__) + '/forecast/adapters/*.*')).map{ |f| File.basename(f, '_adapter.rb') };
   
-  include Forecast::Model
+  def method_missing(method, *args, &block)
+    @source.send(method, *args, &block)
+  end
+  
+  def initialize(attrs = {})
+    @source = OpenStruct.new(attrs)
+  end
   
-  attr_accessor :latitude, :longitude, :date, :temp, :temp_min, :temp_max, :condition, :orig_condition
+  def as_json(options = nil)
+    @source.table.as_json(options)
+  end
+  
+  def to_json *a
+    self.marshal_dump.to_json a
+  end
+  
+  def icon
+    # Pick icon from theme
+    if self.condition != nil && Forecast.config.theme.is_a?(Hash)
+      icon_prefix = Forecast.config.theme.has_key?('prefix') ? Forecast.config.theme['prefix'] : ''
+      icon_suffix = Forecast.config.theme.has_key?('suffix') ? Forecast.config.theme['suffix'] : ''
+      icon_name = Forecast.config.theme['conditions'].has_key?(self.condition) ? Forecast.config.theme['conditions'][self.condition] : self.condition
+      # Dasherize
+      icon_name = icon_name.to_s.gsub(/(.)([A-Z])/,'\1-\2').gsub(/\s*/, '').downcase
+      icon = icon_prefix + icon_name + icon_suffix
+      return icon != nil ? icon : self.icon
+    end
+    # Slugified condition as icon name
+    self.condition.is_a?(String) && self.condition.downcase.strip.gsub(' ', '-').gsub(/[^\w-]/, '')
+  end
   
   # class
   class << self
   
     def current(latitude, longitude)
-      cache_key = "current:#{latitude},#{longitude}"
-      forecast = read_cache(cache_key)
-      if forecast == nil
-        forecast = adapter.current(latitude, longitude)
-        write_cache(cache_key, forecast)
-      end
-      return forecast
+      return adapter.current(latitude, longitude)
     end
     
     def hourly(latitude, longitude)
-      cache_key = "hourly:#{latitude},#{longitude}"
-      forecasts = read_cache(cache_key)
-      if forecasts == nil
-        forecasts = adapter.hourly(latitude, longitude)
-        write_cache(cache_key, forecasts)
-      end
-      return forecasts
+      return adapter.hourly(latitude, longitude)
     end
     
     def daily(latitude, longitude)
-      cache_key = "daily:#{latitude},#{longitude}"
-      forecasts = read_cache(cache_key)
-      if forecasts == nil
-        forecasts = adapter.daily(latitude, longitude)
-        write_cache(cache_key, forecasts)
-      end
-      return forecasts
+      return adapter.daily(latitude, longitude)
     end
     
-    private 
-
-      @adapter = nil
-      
+    private
+    
       def adapter
         if @adapter == nil
           @adapter = Forecast::Adapter.instance
         end
         return @adapter
       end
-      
-          
-      @cache = nil
-      
-      def cache
-        cache = Forecast.config.cache
-        if @cache == nil && ( cache != nil || (!!cache == cache) && cache == true )
-          if !!cache == cache
-            Forecast.config.cache = {
-              expire: 5, 
-              prefix: :forecast, 
-              host: "127.0.0.1", 
-              port: "6379", 
-              url: nil
-            }
-          end
-          cache_config = Forecast.config.cache
-          begin
-            if cache_config['url'] != nil
-              redis_url = cache_config['url']
-              uri = URI.parse(redis_url)
-              @cache = Redis.new(host: uri.host, port: uri.port, password: uri.password)
-            else
-              @cache = Redis.new(host: cache_config['host'], port: cache_config['port'])
-            end
-            @cache.ping
-          rescue
-            puts "error connecting to redis"
-          end
-        end
-        return @cache
-      end
-      
-      def cache_key(key)
-        cache_prefix = Forecast.config.cache[:prefix]
-        return "#{cache_prefix.to_s}:#{key}"
-      end
-      
-      def cache_expire
-        cache_expire = Forecast.config.cache[:expire]
-      end
-    
-      def write_cache(key, data)
-        if cache == nil
-          return;
-        end
-        puts "WRITE TO CACHE... " + cache_key(key).to_s + ", cache_expire: " + cache_expire.to_s
-        cache.set(cache_key(key), data.to_json)
-        cache.expire(cache_key(key), cache_expire)
-      end
-    
-      def read_cache(key)
-        if cache == nil
-          return nil;
-        end
-        cached_result = cache.get(cache_key(key))
-        result = nil
-        if cached_result != nil
-          puts "READ FROM CACHE: " + cache_key(key).to_s + ", cache_expire: " + cache_expire.to_s
-          json = JSON.parse(cached_result)
-          if json.is_a?(Array)
-            result = Forecast::Collection.new
-            json.each do |obj|
-              forecast = Forecast.new
-              forecast.from_json(obj)
-              result << forecast
-            end
-          elsif json.is_a?(Object)
-            result = Forecast.new
-            result.from_json(json)
-          end
-        end
-        return result
-      end
-    
-      
     
   end
   

data/spec/fixtures/locations.yml

@@ -0,0 +1,21 @@
+New York: 
+  latitude: 41.145495
+  longitude: -73.994901
+Miami:
+  latitude: 25.775278
+  longitude: -80.208889
+San Francisco:
+  latitude: 37.783333
+  longitude: -122.416667
+London:
+  latitude: 51.50939
+  longitude: -0.11832
+Johannesburg:
+  latitude: -26.204444
+  longitude: 28.045556
+Sidney:
+  latitude: -33.865
+  longitude: 151.209444
+Hamburg:
+  latitude: 53.55075
+  longitude: 9.93026