weatherzone 0.5.8

data/lib/vendor/openuri_memcached/License.txt

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

data/lib/vendor/openuri_memcached/README.markdown

@@ -0,0 +1,48 @@
+# OpenURI with caching
+
+Carelessly make OpenURI requests without getting hate mail.
+
+## Running with MemCached
+
+Require the library
+
+    require 'openuri/memcached'
+  
+Start memcached server
+  
+    ben@Spinners ~/ Ϟ memcached -d
+
+Set your memcached host/s (defaults to 127.0.0.1:11211)
+  
+    OpenURI::Cache.host = ['10.1.1.10:11211', '10.1.1.11:11211']
+
+The default expiry is 15 minutes, this can be changed using the `expiry` method
+    
+    # Ten long minutes
+    OpenURI::Cache.expiry = 600
+    
+## Running using Rails cache
+
+You can also cache your OpenURI calls using Rails cache. 
+require the library using `require openuri/rails-cache`
+  
+### Execution
+Use exactly the same as you would OpenURI, only.. enable it.
+
+    OpenURI::Cache.enable!
+    # As slow a wet week
+    open("http://ab-c.com.au").read 
+  
+Quit your app (leave memcached running) and re-run the same request, It will come from cache.
+
+### Requirements
+
+* Ruby
+* MemCached 
+* memcache (gem)
+  * You will need to ensure that you have [corresponding version](http://blog.evanweaver.com/files/doc/fauna/memcached/files/COMPATIBILITY.html) of libmemcached to the memcached gem installed for installation to go by breezy
+
+### Contributors
+
+* [Ben Askins](http://github.com/benaskins)
+* [Rick Olson](http://github.com/technoweenie)

data/lib/vendor/openuri_memcached/lib/openuri/common.rb

@@ -0,0 +1,117 @@
+require 'open-uri'
+
+module Kernel
+  private 
+  alias openuri_original_open open
+  def open(name, *rest, &block)
+    if name.respond_to?(:open)
+      name.open(*rest, &block)
+    elsif name.respond_to?(:to_str) &&
+          %r{\A[A-Za-z][A-Za-z0-9+\-\.]*://} =~ name &&
+          (uri = URI.parse(name)).respond_to?(:open)
+      OpenURI::open(name, *rest, &block)
+    else
+      open_uri_original_open(name, *rest, &block)
+    end
+  end
+  module_function :open, :openuri_original_open
+end
+
+module OpenURI
+  alias original_open open #:nodoc:
+  def self.open(uri, *rest, &block)
+    if Cache.enabled?
+      response = Cache.get(Cache.key_for(uri))
+    end
+    
+    unless response
+      response = openuri_original_open(uri, *rest).read
+      Cache.set(Cache.key_for(uri), response) if Cache.enabled?
+    end
+
+    response = StringIO.new(response)
+
+    if block_given?
+      begin
+        yield response
+      ensure
+        response.close
+      end
+    else
+      response
+    end
+  end
+  
+  class Cache
+
+    class KeyHash
+      def self.enable!
+        @hash_keys = true
+      end
+      
+      def self.disable!
+        @hash_keys = false
+      end
+
+      def self.enabled?
+        @hash_keys
+      end
+      
+      def self.disabled?
+        !@hash_keys
+      end
+      
+      def self.generate(uri)
+        Digest::MD5.hexdigest(uri)
+      end
+    end
+    
+    # Cache is not enabled by default
+    @cache_enabled = false
+    
+    class << self
+      attr_writer :expiry, :host
+      
+      # Is the cache enabled?
+      def enabled?
+        @cache_enabled
+      end
+      
+      # Enable caching
+      def enable!
+        raise NotImplementedError
+      end
+      
+      # Disable caching - all queries will be run directly 
+      # using the standard OpenURI `open` method.
+      def disable!
+        @cache_enabled = false
+      end
+
+      def disabled?
+        !@cache_enabled
+      end
+      
+      def get(key)
+        raise NotImplementedError
+      end
+      
+      def set(key, value)
+        raise NotImplementedError
+      end
+            
+      def key_for(uri)
+        Cache::KeyHash.enabled? ? Cache::KeyHash.generate(uri.to_s) : uri.to_s
+      end      
+      
+      # How long your caches will be kept for (in seconds)
+      def expiry
+        @expiry ||= 60 * 10
+      end
+      
+      def host
+        @host ||= "127.0.0.1:11211"
+      end
+    end
+  end
+end

data/lib/vendor/openuri_memcached/lib/openuri/memcached.rb

@@ -0,0 +1,36 @@
+require 'openuri/common'
+
+begin
+  require 'minigems'
+rescue LoadError
+  require 'rubygems'
+end
+
+gem "memcached", ">= 0.10"
+require 'memcached'
+
+module OpenURI
+  class Cache
+    class << self
+      # Enable caching
+      def enable!
+        @cache ||= Memcached.new(host, {
+          :namespace => 'openuri', 
+          :no_block => true,
+          :buffer_requests => true
+        })
+        @cache_enabled = true
+      end
+      
+      def get(key)
+        @cache.get(key)
+      rescue Memcached::NotFound
+        false
+      end
+      
+      def set(key, value)
+        @cache.set(key, value, expiry)
+      end
+    end
+  end
+end

data/lib/vendor/openuri_memcached/lib/openuri/rails-cache.rb

@@ -0,0 +1,21 @@
+require 'openuri/common'
+
+module OpenURI
+  class Cache
+    class << self
+      # Enable caching
+      def enable!
+        @cache = Rails.cache
+        @cache_enabled = true
+      end
+      
+      def get(key)
+        @cache.read(key)
+      end
+      
+      def set(key, value)
+        @cache.write(key, value, :expires_in => expiry)
+      end
+    end
+  end
+end

data/lib/vendor/openuri_memcached/lib/openuri_memcached.rb

@@ -0,0 +1 @@
+require 'openuri/memcached'

data/lib/weatherzone.rb

@@ -0,0 +1,39 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'rubygems'
+require 'digest/md5'
+require 'timeout'
+
+require 'nokogiri'
+require 'sax-machine'
+require 'tzinfo'
+
+begin
+  $LOAD_PATH << File.join(File.dirname(__FILE__), *%w[vendor openuri_memcached lib])
+  if defined? Rails
+    require 'openuri/rails-cache'
+  else
+    require 'openuri/memcached'
+    # Cache for 10 minutes. The web service caches for the same period, so this ensures we've always got
+    # the freshest data and the speediest response.
+    OpenURI::Cache.expiry = 600
+  end
+rescue LoadError
+  require 'open-uri'
+end
+
+unless defined?(ActiveSupport)
+  require 'ext/class'
+  require 'ext/object'
+end
+
+require 'weatherzone/finder'
+require 'weatherzone/resource'
+require 'weatherzone/helpers/almanac_element'
+require 'weatherzone/helpers/date_parser'
+require 'weatherzone/helpers/units'
+
+module Weatherzone
+  VERSION = '0.5.8'
+end

data/lib/weatherzone/connection.rb

@@ -0,0 +1,85 @@
+require 'singleton'
+
+module Weatherzone  
+  
+  class RequestFailed < Exception
+    attr_reader :message
+    def initialize(url)
+      @message = "Failed to retreive #{url} and no cached version available"
+    end
+  end
+  
+  class Settings
+    include Singleton
+    attr_accessor :strip_scale_from_units, :weather_class
+  end
+  
+  class Connection
+
+    DEFAULT_TIMEOUT_AFTER = 1
+
+    include Singleton
+
+    attr_accessor :username, :password, :url, :keygen, :logger, :timeout_after
+    
+    def initialize
+      @logger       = Logger.new(STDOUT)
+      @logger.level = Logger::DEBUG
+    end
+    
+    def self.connect(username=nil, password=nil, options={}, &block)
+      connection               = Weatherzone::Connection.instance
+      connection.username      = username
+      connection.password      = password
+      connection.url           = options[:url]
+      connection.keygen        = block
+      connection.logger        = options[:logger]
+      connection.timeout_after = options[:timeout_after] || DEFAULT_TIMEOUT_AFTER
+    end
+  
+    def self.settings
+      Weatherzone::Settings.instance
+    end
+    
+    def settings
+      self.class.settings
+    end
+  
+    def key
+      @keygen.call
+    end
+    
+    def base_url
+      @base_url ||= "#{self.url}?u=#{username}&k=#{key}"
+    end
+    
+    def wz_url_for(params)
+      "#{base_url}#{params}"
+    end
+    
+    def request(params)
+      url = wz_url_for(params)
+      info("GET #{url}")
+      timeout(self.timeout_after) do
+        response = OpenURI::open(url)
+        response.read
+      end
+    rescue Timeout::Error, SocketError
+      error("webservice connection failed")
+      raise RequestFailed.new(url)
+    end
+    
+    def debug(message)
+      @logger.debug("[weatherzone] #{message}") if @logger
+    end
+
+    def info(message)
+      @logger.info("[weatherzone] #{message}") if @logger
+    end
+
+    def error(message)
+      @logger.error("[weatherzone] #{message}") if @logger
+    end
+    
+  end
+end

data/lib/weatherzone/finder.rb

@@ -0,0 +1,129 @@
+module Weatherzone
+  module Finder
+
+    INCLUDES_MAP = {
+      :forecasts => "fc=1",
+      :point_forecasts => "fc=3",
+      :district_forecasts => "dist_fc=1",
+      :conditions => "obs=1",
+      :warnings => "warn=2",
+      :state_forecasts => "state_fc=1",
+      :uv_index => "uv=1",
+      :sun => "fc_sun=2",
+      :moon => "fc_moon=1",
+      :historical_observations => "histobs=1",
+      :daily_observations => "dlyobs=7",
+      :position => "latlon=1",
+      :moon_phases => "moon=1",
+      :news_items => "news=2",
+      :almanac => "almanac=1",
+      :links => "links=1",
+      :radar_animator => "ra=1",
+      :radar_still => "rs=1",
+      :satellite_animator => "sa=1",
+      :satellite_still => "ss=1",
+      :marine_forecast => "marine=1",
+      :tides => "tides=4",
+      :tide_height => "tideh=1",
+      :surf_report => "surf_rpt=2",
+      :climate_periods => "climate=1(months=12)",
+      :related_locations => "locdet=1",
+      :buoy_observations => "buoy=1(period=24)"
+    } 
+
+    def self.included(klass)
+      klass.class_eval do
+        @@connection = Weatherzone::Connection.instance
+
+        class << self
+          def find(options, location_code=nil)
+            set_options(options)
+            make_request(build_params(location_code, options))
+          end
+          
+          def find_by_location_code(location_code, options={})
+            options = options.dup
+            find(options, location_code)
+          end
+          
+          def find_by_twcid(twcid, options={})
+            options = options.dup
+            options.merge!(:params => "&lt=twcid&lc=#{twcid}")
+            find(options)
+          end
+
+          def find_by_location_name(location_name, options={})
+            options = options.dup
+            location_name = location_name.gsub(" ", "%20").gsub("-", "%20")
+            options.merge!(:params => "&lt=aploc&ln=#{location_name}")
+            find(options)
+          end
+
+          def find_by_swellnet_code(swellnet_code, options={})
+            options = options.dup
+            options.merge!(:params => "&lt=swellnet&lc=#{swellnet_code}")
+            find(options)
+          end
+
+          def find_by_location_filter(filter, options={})
+            options = options.dup
+            options.merge!(:params => "&lt=twcid&lf=#{filter}")
+            find(options)
+          end
+          
+          def find_by_district(district_code, options={})
+            options = options.dup
+            options.merge!(:params => "&lt=twcid&dist=#{district_code}")
+            find(options)            
+          end
+
+          def find_districts_by_state(state, options={})
+            options = options.dup
+            options.merge!(:params => "&lt=dist&state=#{state}")
+            find(options).countries.first.locations
+          end
+
+          def build_params(location_code, options)
+            params = location_code ? "&lc=#{location_code}" : ""
+            params  += options.delete(:params)                  if options[:params]
+            params  += include_params(options.delete(:include)) if options[:include]
+            params  += include_image(options.delete(:image))    if options[:image]
+            params  += parse_params(options) unless options.empty?
+            params
+          end
+
+          protected
+          def set_options(options)
+            @@connection.settings.weather_class ||= self
+            self.temperature_unit = options.delete(:temperature_unit)
+          end
+
+          def make_request(params)
+            response = @@connection.request(params)
+            parse(response)
+          end
+          
+          def include_params(includes)
+            includes.inject("") do |params, relationship|
+              if param = INCLUDES_MAP[relationship]
+                params += "&#{param}"
+              else
+                params
+              end
+            end
+          end
+  
+          def include_image(image)
+            "&images=#{image[:type]}(days=#{image[:days]};size=#{image[:size]})"   
+          end
+
+          def parse_params(options)
+            options.inject("") do |params, (key, value)|
+              params += "&#{key}=#{value}"
+            end      
+          end
+        end
+      end
+    end
+  end
+end