forecast 0.0.2

data/lib/forecast/adapter.rb

@@ -0,0 +1,204 @@
+require 'net/http'
+require 'rexml/document'
+require 'open-uri'
+require 'json'
+
+class Forecast
+  module Adapter
+    
+    @options = nil
+    
+    module ClassMethods
+      def slug
+        self.name.split('::').last.gsub(/Adapter$/, '').gsub(/(.)([A-Z])/,'\1_\2').downcase
+      end
+    end
+    
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    
+    def self.instance
+      provider = Forecast.config.provider
+      if 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
+        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'
+      end
+    end
+    
+    def initialize(options = {})
+      @options = options
+    end
+    
+    def options
+      @options
+    end
+    
+    def config
+      Forecast.config.adapters[self.class.slug] || {}
+    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
+      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
+      end
+      
+      def metric(fahrenheit)
+        ((fahrenheit - 32) / 1.800).round()
+      end
+      
+      def get_temp(fahrenheit)
+        fahrenheit = fahrenheit.to_i.round()
+        Forecast.config.temp_scale.to_sym == :metric ? metric(fahrenheit) : fahrenheit
+      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
+        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
+      
+      def get_condition_by_similarity(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
+          end
+      end
+      
+      def get_condition_name(match)
+        if match == nil 
+          return nil
+        end
+        conditions = Forecast.config.conditions
+        condition = "Unknown"
+        if conditions.keys.include?(match)
+          condition = conditions[match]
+        elsif conditions.values.include?(match)
+          condition = match
+        end
+        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)
+          end
+          if condition
+            break
+          end
+        end
+        get_condition_name(condition)
+      end
+      
+      private 
+      
+        def is_numeric?(s)
+          begin
+            Float(s)
+          rescue
+            false # not numeric
+          else
+            true # numeric
+          end
+        end
+      
+  end
+end

data/lib/forecast/adapters/open_weather_map_adapter.rb

@@ -0,0 +1,95 @@
+class Forecast
+  module Adapters
+    class OpenWeatherMapAdapter
+      
+      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
+        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
+          end
+        end
+        return forecasts
+      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'])
+            if condition != nil
+              forecast.condition = condition
+              break
+            end 
+          end
+          forecasts << forecast
+        end
+        return forecasts
+      end
+      
+      private
+      
+        def api_url(action, latitude, longitude)
+          url = "http://api.openweathermap.org/data/2.5/#{action}"
+          params = {
+            lat: latitude, 
+            lon: longitude 
+          }
+          if options[:api_key]
+            params['APPID'] = options[:api_key]
+          end
+          query_string = URI.encode_www_form(params)
+          return url + "?" + query_string
+        end
+        
+        def kelvin_to_fahrenheit(kelvin)
+          return ((kelvin - 273.15) * 1.8000 + 32).round
+        end
+      
+    end
+  end
+end
+
+
+
+
+    

data/lib/forecast/adapters/open_weather_map_adapter.yml

@@ -0,0 +1,18 @@
+forecast: 
+  adapters:
+    open_weather_map:
+      conditions:  
+        200..210: Windy
+        211: Storm
+        212..299: 'Heavy Storm'
+        300..399: 'Light Rain'
+        500: 'Light Rain'
+        501: 'Rain' 
+        502..599: 'Heavy Rain'
+        600: 'Light Snow'
+        601: 'Snow'
+        602..699: 'Heavy Snow'
+        800: 'Clear'
+        801: 'Partly Cloudy'
+        802..803: 210
+        804..899: 'Mostly Cloudy'

data/lib/forecast/adapters/wunderground_adapter.rb

@@ -0,0 +1,70 @@
+class Forecast
+  module Adapters
+    class WundergroundAdapter
+      
+      include Forecast::Adapter
+      
+      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']
+        end
+        return forecast
+      end
+      
+      def hourly(latitude, longitude)
+        forecasts = Forecast::Collection.new
+        result = get_json(api_url('hourly', latitude, longitude))
+        if result
+          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']
+            forecasts << forecast
+           end
+        end
+        return forecasts
+      end
+      
+      def daily(latitude, longitude)
+        forecasts = Forecast::Collection.new
+        result = get_json(api_url('forecast', latitude, longitude))
+        if result
+          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']
+            forecasts << forecast
+           end
+        end
+        return forecasts
+      end
+      
+      private 
+          
+        def api_url(action, latitude, longitude)
+          url = "http://api.wunderground.com/api/#{options['api_key']}/#{action}/q/#{latitude},#{longitude}.json"
+        end
+      
+    end
+  end
+end
+
+
+
+
+    

data/lib/forecast/adapters/yahoo_adapter.rb

@@ -0,0 +1,90 @@
+class Forecast
+  module Adapters
+    class YahooAdapter
+      
+      include Forecast::Adapter
+      
+      URL_YQL = 'http://query.yahooapis.com/v1/public/yql'
+      URL_RSS = 'http://weather.yahooapis.com/forecastrss'
+      
+      def current(latitude, longitude)
+        forecast = nil
+        doc = get_rss(latitude, longitude)
+        if doc
+          forecast = Forecast.new
+          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
+            end
+          end
+        end
+        return forecast
+      end
+      
+      def hourly(latitude, longitude)
+        # not supported
+        return []
+      end
+      
+      def daily(latitude, longitude)
+        doc = get_rss(latitude, longitude)
+        forecasts = Forecast::Collection.new
+        if doc
+          doc.elements.each('rss/channel/item/yweather:forecast') do |elem|
+            forecast = Forecast.new
+            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
+            end
+            forecast.temp = (forecast.temp_min + forecast.temp_max) / 2
+            forecasts << forecast
+          end
+        end
+        return forecasts
+      end
+      
+      private 
+      
+        def get_woeid(latitude, longitude)
+          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.elements.each('query/results/Result/woeid') do |elem|
+            woeid = elem.text
+          end
+          return woeid
+        end
+        
+        def get_rss(latitude, longitude)
+          woeid = get_woeid(latitude, longitude)
+          if woeid
+            doc = get_doc(URL_RSS, {w: woeid})
+            return doc
+          end
+          return nil
+        end
+        
+    end
+  end
+end

data/lib/forecast/cache.rb

@@ -0,0 +1,7 @@
+class Forecast
+  class Cache
+    def initialize
+      
+    end
+  end
+end

data/lib/forecast/collection.rb

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

data/lib/forecast/conditions.yml

@@ -0,0 +1,12 @@
+forecast:
+  conditions: 
+    100: 'Clear'
+    200: 'Partly Cloudy'
+    210: 'Cloudy'
+    220: 'Mostly Cloudy'
+    300: 'Light Rain'
+    310: 'Rain'
+    320: 'Heavy Rain'
+    400: 'Light Snow'
+    410: 'Snow'
+    500: 'Thunderstorm'

data/lib/forecast/config.rb

@@ -0,0 +1,74 @@
+class Forecast
+  class Config
+      
+    attr_accessor :adapters, :provider, :temp_scale, :conditions, :cache, :themes, :theme
+    
+    def initialize
+      
+      @config_file = File.dirname(File.dirname(File.dirname(__FILE__))) + "/config/forecast.yml"
+      
+      self.load(File.dirname(__FILE__) + '/**/*.yml')
+      self.load(@config_file)
+      
+      def theme
+        if @theme != nil 
+          if @theme.is_a?(Hash)
+            return @theme
+          end
+          if themes[@theme] != nil
+            return themes[@theme]
+          end
+        end
+        return @theme
+      end
+      
+    end
+    
+    def load(pattern)
+      Dir.glob(pattern).sort{ |a, b| a.split(/\//).length <=> b.split(/\//).length}.reverse.each do |f|
+        obj = YAML.load_file(f)
+        if obj['forecast'] != nil
+          obj['forecast'].each do |k, v|
+            if respond_to?("#{k}")
+              o = send("#{k}")
+              if o.is_a?(Hash)
+                v = deep_merge(o, v)
+              end
+            end
+            send("#{k}=", v) if respond_to?("#{k}=")
+          end
+        end
+      end
+    end
+    
+    private 
+      
+      def deep_merge(hash, other_hash, &block)
+        other_hash.each_pair do |k,v|
+          tv = hash[k]
+          if tv.is_a?(Hash) && v.is_a?(Hash)
+            hash[k] = deep_merge(tv, v, &block)
+          else
+            hash[k] = block && tv ? block.call(k, tv, v) : v
+          end
+        end
+        hash
+      end
+    
+  end
+  
+  def self.config
+    @@config ||= Config.new
+  end
+  
+  def self.configure
+    yield self.config
+    # puts 'configured'
+    # if self.config.config_file != nil
+      # puts 'load config from file'
+      # self.config.load(@config_file)
+    # end
+  end
+  
+  
+end

data/lib/forecast/config.yml

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

data/lib/forecast/model.rb

@@ -0,0 +1,71 @@
+class Forecast
+  module Model
+    
+    def initialize(object_attribute_hash = {})
+      object_attribute_hash.map do |(k, v)| 
+        send("#{k}=", v) if respond_to?("#{k}=")
+      end
+    end
+    
+    def icon
+      if Forecast.config.theme.is_a? Hash
+        icon = Forecast.config.theme[self.condition]
+        return icon unless icon == nil 
+      end
+      return slugify(self.condition)
+    end
+    
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  
+    def as_json options = {}
+      serialized = Hash.new
+      if self.class.attributes != nil
+        self.class.attributes.each do |attribute|
+          serialized[attribute] = self.public_send attribute
+        end
+      end
+      serialized
+    end
+  
+    def to_json *a
+      as_json.to_json a
+    end
+    
+    def from_json(json)
+      self.class.attributes.each do |attribute|
+        writer_m = "#{attribute}="
+        value = json[attribute.to_s]
+        if attribute == :date
+          value = DateTime.parse(value)
+        end
+        send(writer_m, value) if respond_to?(writer_m)
+      end
+    end
+    
+    # end
+    
+    private 
+    
+      def slugify(string)
+        string.downcase.strip.gsub(' ', '-').gsub(/[^\w-]/, '')
+      end
+      
+      module ClassMethods
+        
+        @attributes = []
+        
+        def attributes
+          @attributes
+        end
+        
+        def attr_accessor *attrs
+          @attributes = Array attrs
+          super
+        end
+        
+      end
+    
+  end
+end

data/lib/forecast/themes/weather_icons.yml

@@ -0,0 +1,10 @@
+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"