radiospieler 0.3.0

data/lib/core-extensions/tls.rb

@@ -0,0 +1,16 @@
+class Module
+  def thread_local_attribute(name, &block)
+    proc = Proc.new if block_given?
+    key = "tls:#{name}"
+
+    singleton_class.class_eval do
+      define_method(name) do
+        Thread.current[key] ||= proc ? proc.call : nil
+      end
+
+      define_method("#{name}=") do |value|
+        Thread.current[key] = value
+      end
+    end
+  end
+end

data/lib/core-extensions/uids.rb

@@ -0,0 +1,16 @@
+require "digest/md5"
+
+class String
+  def crc32
+    Zlib.crc32(self)
+  end
+
+  def md5
+    Digest::MD5.hexdigest(self)
+  end
+
+  # return a 64 bit uid
+  def uid64
+    md5.unpack("LL").inject { |a,b| (a << 31) + b }
+  end
+end

data/lib/core-extensions/uri_ext.rb

@@ -0,0 +1,10 @@
+require "uri"
+
+module URI
+  def self.valid?(uri)
+    parse(uri)
+  rescue URI::InvalidURIError
+    false
+  end
+end
+

data/lib/extensions/bitly.rb

@@ -0,0 +1,34 @@
+require "cgi"
+
+module Bitly
+  TIME_TO_LIVE = 365 * 24 * 3600
+  
+  def self.url_base
+    return @url_base unless @url_base.nil?
+
+    user, key = (App.config[:bitly] || {}).values_at "user", "key"
+
+    @url_base = unless user && key
+      App.logger.warn "Missing or invalid bitly configuration: #{App.config[:bitly]}"
+      false
+    else
+      "https://api-ssl.bitly.com/v3/shorten?login=#{user}&apiKey=#{key}"
+    end
+  end
+  
+  def self.shorten(url)
+    return url if !self.url_base || !url || url.index("/bit.ly/")
+
+    bitly_url = "#{self.url_base}&longUrl=#{CGI.escape(url)}"
+    parsed = JSON.parse Http.get(bitly_url, TIME_TO_LIVE) 
+
+    if parsed["status_code"] == 200
+      bitlified = parsed["data"]["url"] 
+      App.logger.debug "bitlify: #{url} => #{bitlified}"
+      bitlified
+    else
+      App.logger.error "#{url}: bitly error: #{parsed["status_txt"] }"
+      url
+    end
+  end
+end

data/lib/extensions/http.rb

@@ -0,0 +1,60 @@
+require 'net/http'
+
+# The Http module defines a 
+# 
+#   Http.get(url)
+#
+# method.
+module Http
+  extend self
+
+  # the default expiration time for get requests.
+  module MaxAge
+    def self.config
+      @config ||= (App.config["cache-max-age"] || {}).to_a
+    end
+    
+    def self.for(url)
+      config.each do |pattern, max_age|
+        return max_age if url.index(pattern)
+      end
+      nil
+    end
+  end
+  
+  def get(url, max_age = MaxAge.for(url))
+    App.logger.benchmark("[GET] #{url}", :minimum => 20) do 
+      App.cached(url, max_age) do 
+        App.logger.debug "[GET] #{url}"
+        get_(url) 
+      end
+    end
+  end
+
+  private
+  
+  def get_(uri_str, limit = 10)
+    raise 'too many redirections' if limit == 0
+
+    uri = URI.parse(uri_str)
+    
+    http = Net::HTTP.new(uri.host, uri.port)
+    if uri.scheme == "https"
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    end
+    request = Net::HTTP::Get.new(uri.request_uri)
+    response = http.request(request)
+
+    case response
+    when Net::HTTPSuccess then
+      response.body
+    when Net::HTTPRedirection then
+      location = response['location']
+      App.logger.debug "redirected to #{location}"
+      get_(location, limit - 1)
+    else  
+      response.value
+    end
+  end
+end

data/lib/radiospieler.rb

@@ -0,0 +1,13 @@
+# require "micro_sql"
+
+Dir.glob("#{File.dirname(__FILE__)}/core-extensions/*.rb").sort.each do |file|
+  load file
+end
+
+Dir.glob("#{File.dirname(__FILE__)}/radiospieler/*.rb").sort.each do |file|
+  load file
+end
+
+Dir.glob("#{File.dirname(__FILE__)}/extensions/*.rb").sort.each do |file|
+  load file
+end

data/lib/radiospieler/radiospieler.rb

@@ -0,0 +1,13 @@
+module App
+  extend self
+
+  attr :env, true
+
+  def env
+    @env ||= ENV["RACK_ENV"] || ENV["RAILS_ENV"] || "development"
+  end
+end
+
+Dir.glob("#{File.dirname(__FILE__)}/radiospieler/*.rb").sort.each do |file|
+  load file
+end

data/lib/radiospieler/radiospieler/cache.rb

@@ -0,0 +1,77 @@
+require_relative "config"
+
+#
+# This is a cache module, which keeps entries for a certain time period, 
+# stored away in a redis store.
+#
+# Entries are packed via Marshal.
+module App
+  module Cache
+    DEFAULT_MAX_AGE = 4 * 3600     # 4 hours.
+
+    def self.clear
+      store.flushdb
+    end
+
+    def self.uid(key)
+      case key
+      when String, Hash then key.uid64
+      when Fixnum       then key
+      else
+        App.logger.warn "Don't know how to deal with non-uid key #{key}"
+        nil
+      end 
+    end
+    
+    def self.cached(key, max_age = DEFAULT_MAX_AGE, &block)
+      cache_id = uid(key)
+
+      return yield if !store || !max_age || !cache_id
+
+      if marshalled = store.get(cache_id)
+        unmarshal(marshalled)
+      else
+        yield.tap { |v| 
+          store.set(cache_id, marshal(v))
+          store.expire(cache_id, max_age)
+        }
+      end
+    end
+
+    def self.unmarshal(marshalled)
+      Marshal.load Base64.decode64(marshalled) if marshalled
+    end
+    
+    def self.marshal(value)
+      Base64.encode64 Marshal.dump(value)
+    end
+    
+    def self.store_from_url(url)
+      return unless url
+      uri = URI.parse(url)
+      case uri.scheme
+      when "redis"
+        require "redis"
+        Redis.connect(:url => url)
+      when nil
+        SimpleCache.new(uri.path)
+      end
+    end
+    
+    attr :store, true
+    extend self
+    
+    def self.store
+      @store ||= store_from_url(App.config[:cache]) || begin
+        name = "#{File.basename(App.root)}-#{App.root.uid64}"
+        store = SimpleCache.new(name)
+        App.logger.warn "No or invalid :cache configuration, fallback to #{store.path}"
+        store
+      end
+    end
+  end
+
+  def cached(key, max_age = Cache::DEFAULT_MAX_AGE, &block)
+    Cache.cached(key, max_age, &block)
+  end
+end

data/lib/radiospieler/radiospieler/config.rb

@@ -0,0 +1,58 @@
+require_relative "root"
+require_relative "logger"
+
+require "yaml"
+require "erb"
+
+module App
+  module Config
+    def self.paths
+      [ "#{App.root}/config/app.yml", "#{App.root}/config.yml" ]
+    end
+
+    def self.read(path)
+      return unless File.exist?(path)
+      App.logger.info "Reading configuration from #{path}"
+      erb = File.read(path)
+      yaml = ERB.new(erb).result(binding)
+      YAML.load(yaml) || {}
+    end
+    
+    def self.load
+      config = paths.inject(nil) do |c, path|
+        c || read(path)
+      end
+
+      config ||= begin
+        App.logger.warn "No configuration found in #{App.root}"
+        {}
+      end
+    end
+
+    @@configurations = {}
+    
+    def self.current
+      @@configurations[App.root] ||= begin
+        config = self.load
+        default_settings = config["default"] || {}
+        current_settings = config[App.env] || {}
+        default_settings.update current_settings
+      end.extend(TreatSymbolsAsStrings)
+    end
+    
+    module TreatSymbolsAsStrings
+      def [](key)
+        fetch(key) do
+          case key
+          when Symbol then fetch(key.to_s, nil)
+          when String then fetch(key.to_sym, nil)
+          end
+        end
+      end
+    end
+  end
+
+  def config
+    Config.current
+  end
+end

data/lib/radiospieler/radiospieler/logger.rb

@@ -0,0 +1,26 @@
+require "logger"
+
+module App
+  def self.logger
+    @logger
+  end
+
+  INTENDATIONS = {
+    "DEBUG" => '        ',
+    "INFO"  => '      **',
+    "WARN"  => '    ****',
+    "ERROR" => '  ******',
+    "FATAL" => '********'
+  }
+
+  def self.logger=(logger)
+    logger.formatter = proc do |severity, datetime, progname, msg| 
+      intend = INTENDATIONS[severity] || INTENDATIONS["FATAL"]
+      "#{intend} #{msg}\n" 
+    end
+
+    @logger = logger
+  end
+end
+
+App.logger = Logger.new(STDERR)

data/lib/radiospieler/radiospieler/root.rb

@@ -0,0 +1,36 @@
+
+module App
+  # -- app root ---------------------------------------------------------------
+  
+  module Root
+    def self.find_starting_in(dir)
+      if is_root?(dir)
+        dir 
+      elsif !dir.sub!(/\/[^\/]+$/, "")
+        nil
+      else
+        find_starting_in(dir)
+      end
+    end
+
+    def self.is_root?(dir)
+      File.exists?("#{dir}/config.ru") || 
+      File.exists?("#{dir}/Gemfile") ||
+      File.exists?("#{dir}/Procfile")
+    end
+    
+    def self.find
+      find_starting_in(Dir.getwd) || raise("Could not find application root for #{dir}")
+    end
+
+    def root=(root)
+      @root = root
+    end
+
+    def root
+      @root ||= Root.find.tap { |root| App.logger.warn "Application root is #{root}" }
+    end
+  end
+
+  extend Root
+end

data/script/watchr

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+require 'rb-fsevent'
+
+if ARGV.length < 2
+  STDERR.puts "watchr dir ruby-parameter(s)..."
+  abort
+end
+
+paths = ARGV.shift.split(",")
+$args = ARGV.dup
+
+
+def do_ruby
+  STDERR.puts $args.join(" ")
+  STDERR.puts "=" * 80
+  
+  system(*$args)
+end
+
+puts "Initial run"
+do_ruby
+
+fsevent = FSEvent.new
+fsevent.watch paths do |directories|
+  puts "Detected change inside: #{directories.inspect}"
+  do_ruby
+end
+fsevent.run

data/test/app_test.rb

@@ -0,0 +1,56 @@
+require 'helper'
+
+class TestApp < Test::Unit::TestCase
+  def test_root
+    expected = File.expand_path("#{File.dirname(__FILE__)}/..")
+    
+    assert_equal expected, App::Root.find_starting_in(File.dirname(__FILE__))
+    assert_equal expected, App::Root.find
+    assert_equal expected, App.root
+
+    App.root = "foo"
+    assert_equal "foo", App.root
+
+    App.root = nil
+    assert_equal expected, App.root
+  end
+
+  def test_object_attributes
+    a = {}
+    assert_raise(NoMethodError) {  
+      a.foo
+    }
+    
+    a.define_attribute :foo, "bar"
+    assert_equal("bar", a.foo)
+
+    a.define_attribute :foo, "baz"
+    assert_equal("baz", a.foo)
+
+    a.define_attribute :foo, nil
+    assert_equal(nil, a.foo)
+  end
+
+  def test_benchmark_logger
+    r = []
+    
+    logger = Logger.new(STDERR)
+    logger.formatter = proc { |_, _, _, msg| r << msg; nil }
+    
+    foo = logger.benchmark {
+      "foo"
+    }
+    assert_equal("foo", foo)
+    assert_equal(["Benchmark: 0 msecs"], r)
+
+    r = []
+    foo = logger.benchmark("message") { "foo" }
+    assert_equal("foo", foo)
+    assert_equal(["message: 0 msecs"], r)
+
+    r = []
+    foo = logger.benchmark("message", :minimum => 1) { "foo" }
+    assert_equal("foo", foo)
+    assert_equal([], r)
+  end
+end