regentanz 0.2.0

data/lib/regentanz/parser/google_weather.rb

@@ -0,0 +1,100 @@
+module Regentanz
+  module Parser
+    class GoogleWeather
+      require 'iconv'
+
+      XML_ENCODING = 'LATIN1' # source encoding of the XML data
+
+      # Converts a string from XML_ENCODING to UTF-8 using the Iconv library.
+      #
+      # === Note
+      # FIXME The XML source document seems to be delivered LATIN1 or UTF-8, completely
+      # random and unpredictable.
+      #
+      # === Parameters
+      # * +data+: string to convert
+      def convert_encoding data
+        return if data.blank?
+        self.class::XML_ENCODING != "UTF-8" ? Iconv.iconv("UTF-8", self.class::XML_ENCODING, data).flatten.join(" ") : data
+      end
+
+      def parse_current!(xml)
+        return if xml.blank?
+        begin
+          doc = REXML::Document.new(xml)
+          if doc.elements['xml_api_reply/weather/current_conditions']
+            attributes = {}
+            doc.elements['xml_api_reply/weather/current_conditions'].each_element do |ele|
+              attributes.merge! parse_node(ele)
+            end
+            Regentanz::Conditions::Current.new(attributes)
+          end
+        rescue
+          # FIXME should report error
+        end
+      end
+
+      def parse_forecast!(xml)
+        return if xml.blank?
+        forecasts = []
+        begin
+          doc = REXML::Document.new(xml)
+          if doc.elements['xml_api_reply/weather/forecast_conditions']
+            doc.elements.each('xml_api_reply/weather/forecast_conditions') do |forecast_element|
+              attributes = {}
+              forecast_element.each_element { |ele| attributes.merge! parse_node(ele) }
+              forecasts << Regentanz::Conditions::Forecast.new(attributes)
+            end
+          end
+          forecasts
+        rescue
+          # FIXME should report error
+        end
+      end
+
+      #private # FIXME private methods should start here after parse! has been implemented
+
+      # Handles some special treatment for certain sub-elements, transforms _element_
+      # into a hash and returns it.
+      #
+      # === Parameters
+      # * +element+ childnode of type REXML::Element
+      def parse_node(element)
+        hash = {}
+        hash.merge! parse_style(element.attribute("data").to_s) if element.name == "icon"
+        if element.name == "humidity"
+          # Handle the small whitespace just before the '%'
+          hash.merge! element.name => element.attribute("data").to_s.gsub(/(\d+).+%$/, '\1 %')
+        elsif element.name == "icon"
+          # We want the full URL
+          hash.merge! element.name => "http://www.google.com" + element.attribute("data").to_s
+        elsif (element.name == "high" or element.name == "low") and @lang == "en"
+          # Forecast-temperatures in EN are listed in °F; we fix that here
+          temp_f = element.attribute("data").to_s.to_i
+          hash.merge! element.name => ( temp_f - 32 ) * 5 / 9
+        else
+          hash.merge! element.name => element.attribute("data").to_s
+        end
+        hash
+      end
+
+      private
+
+      # Extracts a name for the weather condition from the icon name. Intended to
+      # be used as CSS style class name.
+      #
+      # === Parameters
+      # * +path+ an URI-string to Google's weather icon
+      def parse_style(path)
+        hash = {}
+        unless path.blank?
+          style = File.basename(path) # FIXME is this what we want for everyone?
+          style = style.slice(0, style.rindex(".")).gsub(/_/, '-')
+          hash = { "style" => style }
+        end
+        hash
+      end
+
+    end
+  end
+end

data/lib/regentanz/parser.rb

@@ -0,0 +1 @@
+require 'regentanz/parser/google_weather'

data/lib/regentanz/test_helper.rb

@@ -0,0 +1,52 @@
+module Regentanz
+  module TestHelper
+
+    # Default values used for testing. Use this in your setup methods.
+    # Configuration values can be overriden by supplying a block. See
+    # Regentanz::Configuration for supported values.
+    def setup_regentanz_test_configuration!
+      Regentanz.configure do |config|
+        config.retry_ttl              = Regentanz::Configuration.default_cache_ttl
+        config.do_not_get_weather     = true
+        config.retry_ttl              = Regentanz::Configuration.default_retry_ttl
+        config.suppress_stderr_output = true
+        yield config if block_given? # add settings or override above from client
+      end
+    end
+
+    # Returns an invalid API response that will cause REXML to hickup
+    def invalid_xml_response
+      '<HTML><HEAD><meta http-equiv="content-type" content="text/html;charset=utf-8">' \
+      "<TITLE>302 Moved</TITLE></HEAD><BODY>\n" \
+      "<H1>302 Moved</H1>\n" \
+      "The document has moved\n" \
+      '<A HREF="http://sorry.google.com/sorry/?continue=http://www.google.com/ig/api%3Fweather%3D86747%252CGermany%26hl%3Dde">here</A>' \
+      "</BODY></HTML>\n"
+    end
+
+    # Returns a valid xml api reply based upon ./test/support/valid_response.xml.erb
+    def valid_xml_response
+      filename = File.join(Regentanz.configuration.cache_dir, '..', 'valid_response.xml.erb')
+      xmlerb = ERB.new(File.open(filename, 'r') { |file| file.read })
+      xmlerb.result
+    end
+
+    # Creates a cache file +filename+ with contents of #invalid_xml_response
+    # FIXME this is deprecated with the introduction of Regentanz::Cache::File
+    def create_invalid_xml_response(filename)
+      File.open(filename, "w+") { |f| f.puts invalid_xml_response }
+    end
+
+    # Stub Net::HTTP.get_response to return a semi-dynamic (ie. current date) xml
+    # response-
+    def stub_valid_xml_api_response!
+      mock_response = mock()
+      mock_response.stubs(:body).returns(valid_xml_response)
+      Net::HTTP.stubs(:get_response).returns(mock_response)
+    end
+
+  end
+
+end
+
+include Regentanz::TestHelper

data/lib/regentanz/version.rb

@@ -0,0 +1,4 @@
+module Regentanz
+  VERSION = "0.2.0"
+end
+

data/lib/regentanz.rb

@@ -0,0 +1,12 @@
+require 'active_support'
+require 'active_support/core_ext'
+require 'action_mailer'
+require 'regentanz/version'
+require 'regentanz/cache'
+require 'regentanz/configuration'
+require 'regentanz/configurator'
+require 'regentanz/callbacks'
+require 'regentanz/astronomy'
+require 'regentanz/conditions'
+require 'regentanz/parser'
+require 'regentanz/google_weather'

data/regentanz.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "regentanz/version"
+
+Gem::Specification.new do |s|
+  s.name        = "regentanz"
+  s.version     = Regentanz::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Carsten Zimmermann"]
+  s.email       = ["cz@aegisnet.de"]
+  s.homepage    = ""
+  s.summary     = %q{Library to access the Google Weather API}
+  s.description = %q{Library to access the Google Weather API}
+
+  s.rubyforge_project = "regentanz"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'actionmailer', '~> 3.0.10'
+  s.add_dependency 'activesupport', '~> 3.0.10'
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'mocha'
+  s.add_development_dependency 'bundler'
+  s.add_development_dependency 'redgreen'
+  s.add_development_dependency 'factory_girl'
+
+end

data/test/factories.rb

@@ -0,0 +1,8 @@
+module Regentanz
+  module Test
+    Factory.define :google_weather, :class => Regentanz::GoogleWeather, :default_strategy => :build do |f|
+      f.location "Testhausen"
+      f.cache_id "test"
+    end
+  end
+end

data/test/support/support_mailer.rb

@@ -0,0 +1,7 @@
+class SupportMailer
+
+  def self.deliver_weather_retry_marker_notification!(weather_obj, mode)
+    ActionMailer::Base.deliveries << "fake mail"
+  end
+  
+end

data/test/support/tmp/.gitignore

@@ -0,0 +1 @@
+*.xml

data/test/support/valid_response.xml.erb

@@ -0,0 +1,26 @@
+<?xml version="1.0"?>
+<xml_api_reply version="1">
+    <weather module_id="0" tab_id="0" mobile_row="0" mobile_zipped="1" row="0" section="0" >
+        <forecast_information>
+            <city data="Berlin, Berlin"/><postal_code data="Berlin,Germany"/>
+            <latitude_e6 data=""/>
+            <longitude_e6 data=""/>
+            <forecast_date data="<%= Date.today.strftime("%Y-%m-%d") %>"/>
+            <current_date_time data="<%= 5.minutes.ago.utc.strftime("%Y-%m-%d %H:%M:00") %> +0000"/>
+            <unit_system data="SI"/>
+        </forecast_information>
+        <current_conditions>
+            <condition data="Klar"/><temp_f data="77"/>
+            <temp_c data="25"/>
+            <humidity data="Feuchtigkeit: 57 %"/>
+            <icon data="/ig/images/weather/sunny.gif"/>
+            <wind_condition data="Wind: W mit 24 km/h"/>
+        </current_conditions>
+        <forecast_conditions>
+            <day_of_week data="Do."/><low data="16"/>
+            <high data="31"/>
+            <icon data="/ig/images/weather/chance_of_rain.gif"/>
+            <condition data="Vereinzelt Regen"/>
+        </forecast_conditions>
+    </weather>
+</xml_api_reply>

data/test/test_helper.rb

@@ -0,0 +1,18 @@
+require "rubygems"
+require "bundler/setup"
+
+require "test/unit"
+require "active_support/test_case"
+require 'action_mailer/test_helper'
+Bundler.require(:default, :development)
+require 'test/factories'
+
+# FIXME move SupportMailer into callbacks
+require File.join(File.dirname(__FILE__), 'support', 'support_mailer')
+
+# Configure for test mode
+require 'regentanz/test_helper'
+setup_regentanz_test_configuration! do |config|
+  config.cache_dir    = File.expand_path(File.join(File.dirname(__FILE__), '', 'support', 'tmp'))
+  config.retry_marker = File.expand_path(File.join(File.dirname(__FILE__), 'support', 'tmp', 'test_api_retry.txt'))
+end

data/test/unit/astronomy_test.rb

@@ -0,0 +1,26 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class AstronomyTest < Test::Unit::TestCase
+
+  def setup
+    @object = Object.new
+    @object.extend Regentanz::Astronomy
+  end
+
+  def test_google_weather_should_include_astronomy
+    assert Regentanz::GoogleWeather.included_modules.include?(Regentanz::Astronomy)
+  end
+
+  def test_deg_to_rad
+    assert Regentanz::Astronomy.private_instance_methods.include?("deg_to_rad")
+    degrees = 42
+    assert_equal degrees*Math::PI/180, @object.send(:deg_to_rad, degrees)
+  end
+
+  def test_rad_to_deg
+    assert Regentanz::Astronomy.private_instance_methods.include?("rad_to_deg")
+    radians = 42
+    assert_equal radians*180/Math::PI, @object.send(:rad_to_deg, radians)
+  end
+  
+end

data/test/unit/cache/base_test.rb

@@ -0,0 +1,53 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+require 'digest/sha1'
+
+class Regentanz::Cache::BaseTest < ActiveSupport::TestCase
+
+  LINT_METHODS = [:available?, :expire!, :get, :set, :valid?]
+
+  test "should define public interface for all cache backend" do
+    obj = Regentanz::Cache::Base.new
+    LINT_METHODS.each do |method|
+      assert_respond_to obj, method
+    end
+  end
+
+  test "should have check cache backend compatability via lint class method" do
+    assert_respond_to Regentanz::Cache::Base, :lint
+
+    obj = Object.new
+    assert !Regentanz::Cache::Base.lint(obj)
+    assert !Regentanz::Cache::Base.lint(Object)
+
+    LINT_METHODS.each do |method|
+      Object.any_instance.stubs(method)
+    end
+    assert Regentanz::Cache::Base.lint(obj)
+    assert Regentanz::Cache::Base.lint(Object)
+  end
+
+  test "should have key sanitizer class method" do
+    assert_respond_to Regentanz::Cache::Base, :sanitize_key
+    key = Digest::SHA1.hexdigest("a test string")
+    assert_equal key, Regentanz::Cache::Base.sanitize_key("a test string")
+
+    assert_not_equal Regentanz::Cache::Base.sanitize_key("a test string"),
+      Regentanz::Cache::Base.sanitize_key("another test string")
+  end
+
+  test "should inform about retry state" do
+    obj = Regentanz::Cache::Base.new
+    assert_respond_to obj, :waiting_for_retry?
+  end
+
+  test "should check if retry wait time is over" do
+    obj = Regentanz::Cache::Base.new
+    assert_respond_to obj, :unset_retry_state!
+  end
+
+  test "should enter retry state" do
+    obj = Regentanz::Cache::Base.new
+    assert_respond_to obj, :set_retry_state!
+  end
+
+end

data/test/unit/cache/file_test.rb

@@ -0,0 +1,141 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class Regentanz::Cache::FileTest < ActiveSupport::TestCase
+
+  def setup
+    setup_regentanz_test_configuration!
+  end
+
+  def teardown
+    Dir.glob(File.join(Regentanz.configuration.cache_dir, "**", "*")).each { |file| File.unlink(file) }
+  end
+
+  test "should not fail lint" do
+    assert Regentanz::Cache::Base.lint(Regentanz::Cache::File)
+    assert Regentanz::Cache::Base.lint(Regentanz::Cache::File.new)
+  end
+
+  test "should return filename for key" do
+    obj = Regentanz::Cache::File.new
+    assert_respond_to obj, :filename
+    filename = File.join(Regentanz.configuration.cache_dir, "regentanz_test.xml")
+    assert_equal filename, obj.filename("test")
+  end
+
+  test "should create cache file" do
+    obj = Regentanz::Cache::File.new
+    assert !File.exists?(obj.filename("test"))
+    assert obj.set("test", "some cache values")
+    assert File.exists?(obj.filename("test"))
+  end
+
+  test "should rescue set from saving errors" do
+    File.expects(:open).raises(SystemCallError, "pretend something went wrong")
+    obj = Regentanz::Cache::File.new
+    assert_nothing_raised do
+      assert !obj.set("test", "some cache values")
+    end
+  end
+
+  test "available?" do
+    obj = Regentanz::Cache::File.new
+    assert !obj.available?("test")
+
+    File.new(obj.filename("test"), "w+").close
+    assert obj.available?("test")
+  end
+
+  test "should delete file after expire" do
+    obj = Regentanz::Cache::File.new
+    assert !obj.expire!("test") # nothing to expire, return false
+
+    File.new(obj.filename("test"), "w+").close
+    assert obj.expire!("test")
+    assert !File.exists?(obj.filename("test"))
+  end
+
+  test "should rescue expire from saving errors" do
+    File.expects(:delete).raises(SystemCallError, "pretend something went wrong").once
+    obj = Regentanz::Cache::File.new
+    assert_nothing_raised do
+      File.new(obj.filename("test"), "w+").close
+      assert !obj.expire!("test")
+    end
+  end
+
+  test "should get contents from file" do
+    obj = Regentanz::Cache::File.new
+
+    File.open(obj.filename('test_get'), 'w+') {|file| file.print "cached data" }
+    assert obj.available?('test_get')
+    assert_equal "cached data", obj.get('test_get')
+    # cache not available, return false
+    assert_nil obj.get("does not exist")
+  end
+
+  test "should rescue get from reading errors" do
+    obj = Regentanz::Cache::File.new
+    File.open(obj.filename('test'), 'w+') {|file| file.print "cached data" }
+    File.expects(:open).raises(SystemCallError, "pretend something went wrong").once
+
+    assert_nothing_raised do
+      assert !obj.get("test")
+    end
+  end
+
+  test "should check validity" do
+    obj = Regentanz::Cache::File.new
+    assert !obj.valid?('test')
+    File.open(obj.filename('test'), 'w+') { |file| file.puts valid_xml_response }
+
+    # valid_xml_response contains current datestamp,
+    # so should be valid on all fronts
+    assert obj.valid?('test')
+
+    # Pretend the file is too old
+    Regentanz.configuration.cache_ttl = 0
+    assert !obj.valid?('test')
+  end
+  
+  test "should rescue valid from REXML errors" do
+    obj = Regentanz::Cache::File.new
+    File.open(obj.filename('test'), 'w+') { |file| file.puts invalid_xml_response }
+    REXML::Document.expects(:new).raises(REXML::ParseException, "pretend something went wrong")
+
+    assert_nothing_raised do
+      assert !obj.valid?('test')
+    end
+  end
+
+  # ##############################
+  # Retry-state tests
+  # ##############################
+
+  test "should inform about retry state" do
+    obj = Regentanz::Cache::File.new
+    assert !obj.waiting_for_retry?
+
+    File.expects(:exists?).with(Regentanz.configuration.retry_marker).returns(true)
+    assert obj.waiting_for_retry?
+  end
+
+  test "should check if retry wait time is over" do
+    obj = Regentanz::Cache::File.new
+    File.new(Regentanz.configuration.retry_marker, "w+").close
+    Regentanz.configuration.retry_ttl = 1000.hours.to_i # something incredibly high to warrant retry state
+    assert !obj.unset_retry_state! # not waited long enough
+
+    Regentanz.configuration.retry_ttl = 0
+    assert obj.unset_retry_state!
+    assert !File.exists?(Regentanz.configuration.retry_marker)
+  end
+
+  test "should enter retry state" do
+    obj = Regentanz::Cache::File.new
+    assert !File.exists?(Regentanz.configuration.retry_marker)
+    assert obj.set_retry_state!
+    assert obj.set_retry_state! # subsequent calls return the same
+    assert File.exists?(Regentanz.configuration.retry_marker)
+  end
+
+end

data/test/unit/callbacks_test.rb

@@ -0,0 +1,27 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class CallbacksTest < ActiveSupport::TestCase
+
+  def setup
+    @object = Object.new
+    @object.extend Regentanz::Callbacks
+  end
+
+  def test_should_define_constant
+    assert Regentanz::Callbacks::CALLBACKS
+    expected_callbacks = [:api_failure_detected, :api_failure_resumed]
+    assert_equal expected_callbacks, Regentanz::Callbacks::CALLBACKS
+  end
+
+  def test_google_weather_should_include_callbacks
+    assert Regentanz::GoogleWeather.included_modules.include?(Regentanz::Callbacks)
+    assert Regentanz::GoogleWeather.included_modules.include?(ActiveSupport::Callbacks)
+  end
+
+  def test_should_define_each_callback_method
+    Regentanz::Callbacks::CALLBACKS.each do |callback_method|
+      assert @object.private_methods.include?(callback_method.to_s), "#{callback_method} not defined"
+    end
+  end
+
+end

data/test/unit/configuration_test.rb

@@ -0,0 +1,57 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+require "tmpdir"
+
+class ConfigurationTest < ActiveSupport::TestCase
+
+  test "should configure Regentanz" do
+    assert_respond_to Regentanz, :configure
+    assert_respond_to Regentanz, :configuration
+    assert_not_nil Regentanz.configuration
+
+    Regentanz.configure do |config|
+      config.do_not_get_weather = true
+    end
+    assert_not_nil Regentanz.configuration
+    assert Regentanz.configuration.do_not_get_weather
+  end
+
+  test "should have configuration" do
+    configuration_options = [
+      :base_url,
+      :cache_backend,
+      :cache_dir,
+      :cache_prefix,
+      :cache_ttl,
+      :retry_marker,
+      :retry_ttl,
+      :do_not_get_weather,
+      :suppress_stderr_output
+    ]
+    assert_equal configuration_options, Regentanz::Configuration::OPTIONS, "Diff: #{configuration_options - Regentanz::Configuration::OPTIONS}"
+    obj = Regentanz::Configuration.new
+    configuration_options.each do |config_option|
+      assert_respond_to obj, config_option
+    end
+  end
+
+  test "every DEFAULT_OPTION should have a cattr_accessor" do
+    assert_not_nil Regentanz::Configuration::DEFAULT_OPTIONS
+    Regentanz::Configuration::DEFAULT_OPTIONS.each do |config_option|
+      assert_respond_to Regentanz::Configuration, :"default_#{config_option}"
+      assert_not_nil    Regentanz::Configuration.send(:"default_#{config_option}")
+    end
+
+  end
+
+  test "instance should have sane defaults" do
+    obj = Regentanz::Configuration.new
+    tmpdir = Dir.tmpdir
+    assert_equal "http://www.google.com/ig/api",               obj.base_url
+    assert_equal "#{tmpdir}",                                  obj.cache_dir
+    assert_equal "regentanz",                                  obj.cache_prefix
+    assert_equal 14400,                                        obj.cache_ttl
+    assert_equal 3600,                                         obj.retry_ttl
+    assert_equal "#{tmpdir}/regentanz_api_retry.txt",          obj.retry_marker
+  end
+
+end

data/test/unit/current_condition_test.rb

@@ -0,0 +1,33 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class CurrentConditionTest < ActiveSupport::TestCase
+  
+  test "should define setters and getters" do
+    obj = Regentanz::Conditions::Current.new
+    [:condition, :style, :icon, :humidity, :wind_condition, :temp_c, :temp_f].each do |attr|
+      assert_respond_to obj, attr
+      assert_respond_to obj, :"#{attr}="
+    end
+  end
+
+  test "should initialize with attributes hash" do
+    attributes = {
+      "condition"      => "Klar",
+      "temp_f"         => "77",
+      "temp_c"         => "25",
+      "humidity"       => "Feuchtigkeit: 57 %",
+      "icon"           => "http://www.google.com/ig/images/weather/sunny.gif",
+      "style"          => "sunny",
+      "wind_condition" => "Wind: W mit 24 km/h"
+    }
+    obj = Regentanz::Conditions::Current.new(attributes)
+    assert_equal "Klar", obj.condition
+    assert_equal 77, obj.temp_f
+    assert_equal 25, obj.temp_c
+    assert_equal "Feuchtigkeit: 57 %", obj.humidity
+    assert_equal "http://www.google.com/ig/images/weather/sunny.gif", obj.icon
+    assert_equal "sunny", obj.style
+    assert_equal "Wind: W mit 24 km/h", obj.wind_condition
+  end
+
+end

data/test/unit/forecast_condition_test.rb

@@ -0,0 +1,35 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class ForecastConditionTest < ActiveSupport::TestCase
+  
+  def setup
+    @object = Regentanz::Conditions::Forecast.new
+  end
+
+  test "should define setters and getters" do
+    [:condition, :style, :icon, :day_of_week, :high, :low].each do |attr|
+      assert_respond_to @object, attr
+      assert_respond_to @object, :"#{attr}="
+    end
+  end
+
+  test "should initialize with attributes hash" do
+    attributes = {
+      "high"        => "31",
+      "condition"   => "Vereinzelt Regen",
+      "icon"        => "http://www.google.com/ig/images/weather/chance_of_rain.gif",
+      "day_of_week" =>"Do.",
+      "low"         => "16",
+      "style"       => "chance-of-rain"
+    }
+
+    obj = Regentanz::Conditions::Forecast.new(attributes)
+    assert_equal 31, obj.high
+    assert_equal "Vereinzelt Regen", obj.condition
+    assert_equal "http://www.google.com/ig/images/weather/chance_of_rain.gif", obj.icon
+    assert_equal "Do.", obj.day_of_week
+    assert_equal 16, obj.low
+    assert_equal "chance-of-rain", obj.style
+  end
+
+end