forecast 0.0.7 → 0.0.8

data/lib/forecast/adapter.rb

@@ -3,15 +3,14 @@ require 'rexml/document'
 require 'open-uri'
 require 'json'
 
+require 'forecast/http.rb'
+
 class Forecast
   module Adapter
     
-    @options = nil
+    attr_reader :options
     
     module ClassMethods
-      def slug
-        self.name.split('::').last.gsub(/Adapter$/, '').gsub(/(.)([A-Z])/,'\1_\2').downcase
-      end
     end
     
     def self.included(base)
@@ -19,121 +18,146 @@ class Forecast
     end
     
     def self.instance
+      options = {}
       provider = Forecast.config.provider
-      if provider.is_a?(Hash)
-        adapter_name = provider['adapter'].to_s
+      if provider.is_a?(String) || provider.is_a?(Symbol)
+        adapter_name = provider.to_sym
+      elsif provider.is_a?(Hash)
+        adapter_name = provider[:adapter].to_s
         options = provider.clone
         options.delete('adapter')
-      else
-        adapter_name = provider
-        options = {}
       end
       if adapter_name
+        if Forecast.config.adapters != nil && Forecast.config.adapters.has_key?(adapter_name)
+          options = options.merge(Forecast.config.adapters[adapter_name])
+        end
         adapter_classname = (adapter_name.to_s << "_adapter").split('_').collect!{ |w| w.capitalize }.join
         adapter_class = Object.const_get('Forecast').const_get("Adapters").const_get(adapter_classname)
         adapter_class.new(options)
       else 
-        puts 'no adapter provided'
+        puts 'Adapter not found'
       end
     end
     
     def initialize(options = {})
-      @options = options
+      @options = ({cache: Forecast.config.cache}).merge(options)
+      @http = Http.new({cache: @options[:cache]})
+    end
+    
+    def current(latitude, longitude)
     end
     
-    def options
-      @options
+    def hourly(latitude, longitude)
     end
     
-    def config
-      Forecast.config.adapters[self.class.slug] || {}
+    def daily(latitude, longitude)
     end
     
     protected
     
-      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)
-        if result && result['cod'] != "404"
-          return result
-        end
-        return nil
+      def options
+        @options
       end
-      
-      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
+    
+      def get_json(url)
+        @http.get_json(url)
       end
       
-      def metric(fahrenheit)
-        ((fahrenheit - 32) / 1.800).round()
+      def get_dom(url)
+        @http.get_dom(url)
       end
       
-      def get_temp(fahrenheit)
-        fahrenheit = fahrenheit.to_i.round()
-        Forecast.config.temp_scale.to_sym == :metric ? metric(fahrenheit) : fahrenheit
+      def get_temperature(value, input = :fahrenheit )
+        if value == nil
+          value = 0
+        elsif value.is_a?(Array)
+          value = value.inject{ |sum, v| sum.to_f + v.to_f }.to_f() / value.size
+        elsif value.is_a?(String) || value.is_a?(Numeric)
+          value = value.to_f
+        end
+        if input == :fahrenheit && Forecast.config.scale.to_sym == :kelvin
+          value = Forecast::Utils.fahrenheit_to_kelvin(value)
+        elsif input == :fahrenheit && Forecast.config.scale.to_sym == :celsius
+          value = Forecast::Utils.fahrenheit_to_celsius(value)
+        elsif input == :kelvin && Forecast.config.scale.to_sym == :fahrenheit
+          value = Forecast::Utils.kelvin_to_fahrenheit(value)
+        elsif input == :kelvin && Forecast.config.scale.to_sym == :celsius
+          value = Forecast::Utils.kelvin_to_celsius(value)
+        elsif input == :celsius && Forecast.config.scale.to_sym == :fahrenheit
+          value = Forecast::Utils.celsius_to_fahrenheit(value)
+        elsif input == :celsius && Forecast.config.scale.to_sym == :kelvin
+          value = Forecast::Utils.celsius_to_kelvin(value)
+        end
+        value.round
       end
       
-      def similar_words(first, second)
-        similar_words = 0.0
-        first_words = first.downcase.split(/\s+/)
-        second_words = second.downcase.split(/\s+/)
-        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)
-              if l1 > 0 && l1 < 3
-                similar = 1.0
-              end
-            end
-            similar_words+= similar
-          end
+      def get_time(value)
+        if value.is_a?(Time) || value.is_a?(Date)
+          value.to_datetime
+        elsif value.is_a?(String) && value =~ /\A\d+\Z/ || value.is_a?(Numeric)
+          Time.at(value.to_i).to_datetime
+        elsif value.is_a?(String)
+          DateTime.parse(value.to_s)
+        elsif value.is_a?(DateTime)
+          value
         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
+      def get_text(value)
+        value.capitalize
+      end
+      
+      def get_condition_synonyms(name)
+        result = []
+        synonyms = Forecast.config.synonyms
+        synonym_values = synonyms.flatten.select { |v|
+          Forecast::Utils.word_similarity(name, v) > 0.6
+        }
+        if synonym_values.size > 0
+          c = synonym_values.sort { |a, b| 
+            as = Forecast::Utils.word_similarity(name, a)
+            bs = Forecast::Utils.word_similarity(name, b)
+            as <=> bs
+          }.reverse
+          match = c.first
+          result = synonyms.select do |v|
+           v.include?(match)
+          end.first
         end
-        return matrix.last.last
+        return result
       end
       
-      def get_condition_by_similarity(name)
+      
+      def get_similar_condition(name)
         conditions = Forecast.config.conditions
-          c = conditions.values.sort { |a, b| similar_words(name, a) <=> similar_words(name, b) }.reverse
-          if c.first && similar_words(name, c.first) > 0
-            return c.first
+        condition_synonyms = {}
+        conditions.each do |k, v|
+          condition_synonyms[v] = get_condition_synonyms(v) - [v]
+        end
+        condition_synonym_similarity = {}
+        conditions.each do |k, v|
+          synonyms = [v] + get_condition_synonyms(v)
+          condition_synonym_similarity[v] = get_condition_synonyms(v) - [v]
+          similarity = 0
+          synonyms.each do |synonym|
+            similarity = [similarity, Forecast::Utils.word_similarity(name, synonym)].max
           end
+          condition_synonym_similarity[v] = similarity
+        end
+        c = conditions.values.select { |condition|
+          condition_synonym_similarity[condition] > 0.1
+        }
+        c = c.sort { |a, b|
+          a_similarity = condition_synonym_similarity[a]
+          b_similarity = condition_synonym_similarity[b]
+          a_similarity <=> b_similarity
+        }.reverse
+        if c.first != nil
+          return {
+            condition: c.first,
+            similarity: condition_synonym_similarity[c.first] || 0
+          }
+        end
       end
       
       def get_condition_name(match)
@@ -141,7 +165,7 @@ class Forecast
           return nil
         end
         conditions = Forecast.config.conditions
-        condition = "Unknown"
+        condition = nil
         if conditions.keys.include?(match)
           condition = conditions[match]
         elsif conditions.values.include?(match)
@@ -150,55 +174,34 @@ class Forecast
         return condition
       end
       
-      def match_adapter_condition(api_condition)
-        match = nil
-        conditions = config['conditions']
-        if conditions != nil
-          conditions.each do |key, value|
-            # puts "match key #{api_condition} -> #{key.to_s}, #{value.to_s}"
-            if is_numeric?(api_condition) && key.is_a?(String)
-              if key.include? ".."
-                range = key.split(/\.{2}/)
-                if api_condition.to_i >= range[0].to_i && api_condition.to_i <= range[1].to_i
-                  match = value
-                end
-              end
-            elsif key.to_s == api_condition.to_s
-              match = value;
-            end
-          end
-        end
-        return match
-      end
-      
       def get_condition(api_conditions)
         if !api_conditions.is_a?(Array)
           api_conditions = [api_conditions]
         end
         condition = nil
-        api_conditions.each do |api_condition|
-          match = match_adapter_condition(api_condition)
-          if condition == nil
-            condition = get_condition_by_similarity(api_condition)
+        if api_conditions.length > 0
+          similar_conditions = api_conditions.map { |api_condition|
+            get_similar_condition(api_condition)
+          }.select {|v|
+            v != nil  
+          }
+          similar_condition = similar_conditions.sort { |a,b|
+            a[:similarity] <=> b[:similarity]
+          }.reverse.first
+          if similar_condition
+            condition = similar_condition[:condition]
+            condition_name = get_condition_name(condition)
+            if condition_name == nil
+              condition_name = api_conditions[0]
+            end
           end
-          if condition
-            break
+          if condition_name != nil
+            return condition_name
           end
         end
-        get_condition_name(condition)
+        return "Unknown"
       end
       
-      private 
-      
-        def is_numeric?(s)
-          begin
-            Float(s)
-          rescue
-            false # not numeric
-          else
-            true # numeric
-          end
-        end
       
   end
 end

data/lib/forecast/adapters/forecast_io_adapter.rb

@@ -0,0 +1,57 @@
+class Forecast
+  module Adapters
+    class ForecastIoAdapter
+      
+      include Forecast::Adapter
+      
+      def current(latitude, longitude)
+        result = get_json(get_action(latitude, longitude))
+        get_forecast({latitude: latitude, longitude: longitude}.merge(result['currently'])) unless nil
+      end
+      
+      def hourly(latitude, longitude)
+        result = get_json(get_action(latitude, longitude))
+        forecasts = Forecast::Collection.new
+        result['hourly']['data'].each do |hash|
+          forecasts << get_forecast({latitude: latitude, longitude: longitude}.merge(hash))
+        end
+        return forecasts
+      end
+      
+      def daily(latitude, longitude)
+        result = get_json(get_action(latitude, longitude))
+        forecasts = Forecast::Collection.new
+        result['daily']['data'].each do |hash|
+          forecasts << get_forecast({latitude: latitude, longitude: longitude}.merge(hash))
+        end
+        return forecasts
+      end
+      
+      private
+      
+        def get_action(latitude, longitude)
+          api_key = options[:api_key]
+          return "https://api.forecast.io/forecast/#{api_key}/#{latitude},#{longitude}"
+        end
+        
+        def get_forecast(hash)
+          forecast = Forecast.new(hash)
+          forecast.latitude = hash[:latitude]
+          forecast.longitude = hash[:longitude]
+          forecast.time = get_time(hash['time'])
+          forecast.condition = get_condition(hash['summary'])
+          forecast.text = get_text(hash['summary'])
+          forecast.temperature_min = get_temperature(hash['temperatureMin'], :fahrenheit)
+          forecast.temperature_max = get_temperature(hash['temperatureMax'], :fahrenheit)
+          forecast.temperature = get_temperature(hash.has_key?('temperature') ? hash['temperature'] : [hash['temperatureMin'], hash['temperatureMax']], :fahrenheit)
+          return forecast
+        end
+      
+    end
+  end
+end
+
+
+
+
+    

data/lib/forecast/adapters/open_weather_map_adapter.rb

@@ -5,70 +5,62 @@ class Forecast
       include Forecast::Adapter
       
       def current(latitude, longitude)
-        forecast = nil
-        result = get_json(api_url('weather', latitude, longitude))
-        if result
-          forecast = Forecast.new(latitude: latitude, longitude: longitude)
-          forecast.date = Time.at(result['dt']).to_datetime
-          forecast.temp = get_temp(kelvin_to_fahrenheit(result['main']['temp'])) 
-          result['weather'].each do |obj|
-            condition = get_condition(obj['description'])
-            if condition != nil
-              forecast.condition = condition
-              break
-            end 
-          end
+        hash = get_json(get_action('weather', latitude, longitude))
+        if hash
+          result = get_forecast({latitude: latitude, longitude: longitude}.merge(hash))
+          return result
         end
-        return forecast
       end
       
       def hourly(latitude, longitude)
-        forecasts = Forecast::Collection.new
-        result = get_json(api_url('forecast', latitude, longitude))
-        if result
-          result['list'].each do |item|
-            forecast = Forecast.new(latitude: latitude, longitude:longitude)
-            forecast.date = Time.at(item['dt']).to_datetime
-            forecast.temp = get_temp(kelvin_to_fahrenheit(item['main']['temp']))
-            item['weather'].each do |obj|
-              condition = get_condition([obj['description'], obj['id']])
-              if condition != nil
-                forecast.condition = condition
-                break
-              end 
-            end
-            # forecast.temp_min = item['main']['temp_min']
-            # forecast.temp_max = item['main']['temp_max']
-            forecasts << forecast
+        json = get_json(get_action('forecast', latitude, longitude))
+        result = Forecast::Collection.new
+        if json && json.has_key?('list')
+          json['list'].each do |hash|
+            result << get_forecast({latitude: latitude, longitude: longitude}.merge(hash))
           end
         end
-        return forecasts
+        return result
       end
       
       def daily(latitude, longitude)
-        forecasts = Forecast::Collection.new
-        result = get_json(api_url('forecast/daily', latitude, longitude))
-        result['list'].each do |item|
-          forecast = Forecast.new(latitude: latitude, longitude:longitude)
-          forecast.date = Time.at(item['dt'])
-          forecast.temp_min = get_temp(kelvin_to_fahrenheit(item['temp']['min']))
-          forecast.temp_max = get_temp(kelvin_to_fahrenheit(item['temp']['max']))
-          forecast.temp = (forecast.temp_min + forecast.temp_max) / 2
-          item['weather'].each do |obj|
-            condition = get_condition(obj['description'])
+        json = get_json(get_action('forecast/daily', latitude, longitude))
+        result = Forecast::Collection.new
+        if json && json.has_key?('list')
+          result = Forecast::Collection.new
+          json['list'].each do |hash|
+            result << get_forecast({latitude: latitude, longitude: longitude}.merge(hash))
+          end
+        end
+        return result
+      end
+      
+      protected
+      
+        def get_forecast(hash = {})
+          forecast = Forecast.new()
+          forecast.latitude = hash[:latitude]
+          forecast.longitude = hash[:longitude]
+          forecast.time = get_time(hash['dt'])
+          forecast.temperature = get_temperature(hash.has_key?('main') ? hash['main']['temp'] : hash['temp']['day'], :kelvin)
+          forecast.temperature_min = get_temperature(hash.has_key?('main') ? hash['main']['temp_min'] : hash['temp']['min'], :kelvin)
+          forecast.temperature_max = get_temperature(hash.has_key?('main') ? hash['main']['temp_max'] : hash['temp']['max'], :kelvin)
+          forecast.temperature = ((forecast.temperature_min + forecast.temperature_max) / 2).round
+          hash['weather'].each do |obj|
+            condition = get_condition([obj['description'], obj['main']])
             if condition != nil
+              forecast.text = get_text(obj['description'])
               forecast.condition = condition
               break
-            end 
+            end
           end
-          forecasts << forecast
+          return forecast
         end
-        return forecasts
-      end
-      
+        
+        
       private
       
-        def api_url(action, latitude, longitude)
+        def get_action(action, latitude, longitude)
           url = "http://api.openweathermap.org/data/2.5/#{action}"
           params = {
             lat: latitude, 
@@ -81,15 +73,6 @@ class Forecast
           return url + "?" + query_string
         end
         
-        def kelvin_to_fahrenheit(kelvin)
-          return ((kelvin - 273.15) * 1.8000 + 32).round
-        end
-      
     end
   end
-end
-
-
-
-
-    
+end

data/lib/forecast/adapters/wunderground_adapter.rb

@@ -6,29 +6,20 @@ class Forecast
       
       def current(latitude, longitude)
         forecast = nil
-        result = get_json(api_url('conditions', latitude, longitude))
-        if result
-          item = result['current_observation']
-          forecast = Forecast.new(latitude: latitude, longitude: longitude)
-          forecast.date = Time.rfc822(item['observation_time_rfc822'])
-          forecast.temp = get_temp(item['temp_f'])
-          forecast.condition = get_condition([item['weather']])
-          forecast.orig_condition = item['weather']
+        result = get_json(get_action('conditions', latitude, longitude))
+        if result.has_key?('current_observation')
+          forecast = get_current_forecast(result['current_observation'].merge({latitude: latitude, longitude: longitude}))
         end
         return forecast
       end
       
       def hourly(latitude, longitude)
         forecasts = Forecast::Collection.new
-        result = get_json(api_url('hourly', latitude, longitude))
-        if result
+        result = get_json(get_action('hourly', latitude, longitude))
+        if result.has_key?('hourly_forecast')
           items = result['hourly_forecast']
-          items.each do |item|
-            forecast = Forecast.new(latitude: latitude, longitude:longitude)
-            forecast.date = Time.at(item['FCTTIME']['epoch'].to_i).to_datetime
-            forecast.temp = get_temp(item['temp']['english'])
-            forecast.condition = get_condition([item['condition']])
-            forecast.orig_condition = item['condition']
+          items.each do |hash|
+            forecast = get_hourly_forecast(hash.merge({latitude: latitude, longitude: longitude}))
             forecasts << forecast
            end
         end
@@ -37,17 +28,11 @@ class Forecast
       
       def daily(latitude, longitude)
         forecasts = Forecast::Collection.new
-        result = get_json(api_url('forecast', latitude, longitude))
-        if result
+        result = get_json(get_action('forecast', latitude, longitude))
+        if result.has_key?('forecast')
           items = result['forecast']['simpleforecast']['forecastday']
-          items.each do |item|
-            forecast = Forecast.new(latitude: latitude, longitude:longitude)
-            forecast.date = Time.at(item['date']['epoch'].to_i).to_datetime
-            forecast.temp_min = get_temp(item['low']['fahrenheit'])
-            forecast.temp_max = get_temp(item['high']['fahrenheit'])
-            forecast.temp = (forecast.temp_min + forecast.temp_max) / 2
-            forecast.condition = get_condition([item['conditions']])
-            forecast.orig_condition = item['conditions']
+          items.each do |hash|
+            forecast = get_daily_forecast(hash.merge({latitude: latitude, longitude: longitude}))
             forecasts << forecast
            end
         end
@@ -55,10 +40,49 @@ class Forecast
       end
       
       private 
-          
-        def api_url(action, latitude, longitude)
-          url = "http://api.wunderground.com/api/#{options['api_key']}/#{action}/q/#{latitude},#{longitude}.json"
+        
+        def get_action(action, latitude, longitude)
+          url = "http://api.wunderground.com/api/#{options[:api_key]}/#{action}/q/#{latitude},#{longitude}.json"
         end
+        
+        def get_current_forecast(hash = {})
+          puts 'forecast hash: ' + hash.to_s
+          forecast = Forecast.new()
+          forecast.latitude = hash[:latitude]
+          forecast.longitude = hash[:longitude]
+          forecast.time = get_time(hash['observation_epoch'])
+          forecast.temperature = get_temperature(hash['temp_f'], :fahrenheit)
+          forecast.condition = get_condition(hash['weather'])
+          forecast.text = get_text(hash['weather'])
+          return forecast
+        end
+        
+        def get_hourly_forecast(hash = {})
+          puts 'forecast hash: ' + hash.to_s
+          forecast = Forecast.new()
+          forecast.latitude = hash[:latitude]
+          forecast.longitude = hash[:longitude]
+          forecast.time = get_time(hash['FCTTIME']['epoch'])
+          forecast.temperature = get_temperature(hash['temp']['english'], :fahrenheit)
+          forecast.condition = get_condition([hash['condition']])
+          forecast.text = get_text(hash['condition'])
+          return forecast
+        end
+        
+        def get_daily_forecast(hash = {})
+          puts 'forecast hash: ' + hash.to_s
+          forecast = Forecast.new()
+          forecast.latitude = hash[:latitude]
+          forecast.longitude = hash[:longitude]
+          forecast.time = get_time(hash['date']['epoch'])
+          forecast.temperature_min = get_temperature(hash['low']['fahrenheit'], :fahrenheit)
+          forecast.temperature_max = get_temperature(hash['high']['fahrenheit'], :fahrenheit)
+          forecast.temperature = get_temperature([hash['low']['fahrenheit'], hash['high']['fahrenheit']], :fahrenheit)
+          forecast.condition = get_condition(hash['conditions'])
+          forecast.text = get_text(hash['conditions'])
+          return forecast
+        end
+        
       
     end
   end