shoutout 0.0.1

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem "activesupport"
+gem "terminal-notifier"

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Douwe Maan
+
+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/README.md

@@ -0,0 +1,101 @@
+# shoutout
+
+A Ruby library for easily getting metadata from Shoutcast-compatible audio streaming servers.
+
+## Installation
+
+```sh
+gem install shoutout
+```
+
+Or in your Gemfile:
+
+```ruby
+gem "shoutout"
+```
+
+## Usage
+
+```ruby
+require "shoutout"
+
+shoutout = Shoutout.new("http://82.201.100.5:8000/radio538")
+
+# Explicitly open a connection with the server. You're responsible for closing this connection using `#disconnect`.
+shoutout.connect
+
+# If you call any of the reader methods below without having explicitly opened a connection, 
+# one will be opened and closed around reading the information implicitly.
+# This is convenient if you're only looking for one piece of information, but it is of course 
+# very inefficient if you're going to do multiple reads.
+
+# Stream info
+shoutout.name         # => "RADIO538" 
+shoutout.description  # => "ARE YOU IN"
+shoutout.genre        # => "Various"
+shoutout.notice       # => nil in this case, but this could very well have a value for your stream
+shoutout.content_type # => "audio/mpeg"
+shoutout.bitrate      # => 128
+shoutout.public?      # => true
+shoutout.audio_info   # => { :samplerate => 44100, :bitrate => 128, :channels => 2 }
+
+# Current metadata
+shoutout.metadata # => { "StreamTitle" => "ARMIN VAN BUUREN - THIS IS WHAT IT FEELS LIKE", "StreamUrl" => "http://www.radio538.nl" }
+
+# The Metadata object is a Hash that has been extended with the following features:
+shoutout.metadata[:stream_title]  # => "ARMIN VAN BUUREN - THIS IS WHAT IT FEELS LIKE"
+shoutout.metadata[:stream_url]    # => "http://www.radio538.nl"
+shoutout.metadata.now_playing     # => "ARMIN VAN BUUREN - THIS IS WHAT IT FEELS LIKE"
+shoutout.metadata.website         # => "http://www.radio538.nl"
+shoutout.metadata.artist          # => "ARMIN VAN BUUREN"
+shoutout.metadata.song            # => "THIS IS WHAT IT FEELS LIKE"
+
+# Conveniently, `#now_playing` and `#website` are also available on the Shoutout instance:
+shoutout.now_playing  # => "ARMIN VAN BUUREN - THIS IS WHAT IT FEELS LIKE"
+shoutout.website      # => "http://www.radio538.nl"
+
+# For convenience, all of the reader methods above are also available as class methods:
+Shoutout.now_playing("http://82.201.100.5:8000/radio538") # => "ARMIN VAN BUUREN - THIS IS WHAT IT FEELS LIKE"
+# Just like the equivalent `Shoutout.new("http://82.201.100.5:8000/radio538").now_playing`,
+# this will automatically open and close a connection around reading the information.
+
+# You can have a block called every time the metadata changes:
+shoutout.metadata_change do |metadata|
+  puts "Now playing: #{metadata.song} by #{metadata.artist}"
+end
+# Of course, this only works with an explicitly opened connection.
+
+# If you're done setting up but want the program to keep listening for metadata, say so:
+shoutout.listen
+# Note that listening will only end when the connection is lost or the end of file is reached, 
+# so anything that comes after this call will only then be executed. 
+# This will generally be the last call in your program.
+
+# If we don't want to wait around and listen, just let the program exit or disconnect explicitly:
+shoutout.disconnect
+```
+
+## Examples
+Check out the [`examples/`](examples) folder for an example that I actually use myself.
+
+## License
+Copyright (c) 2013 Douwe Maan
+
+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/Rakefile

@@ -0,0 +1,17 @@
+require "rspec/core/rake_task"
+
+spec = Gem::Specification.load("shoutout.gemspec")
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec
+
+desc "Build the .gem file"
+task :build do
+  system "gem build #{spec.name}.gemspec"
+end
+
+desc "Push the .gem file to rubygems.org"
+task release: :build do
+  system "gem push #{spec.name}-#{spec.version}.gem"
+end

data/lib/shoutout/headers.rb

@@ -0,0 +1,66 @@
+class Shoutout
+  class Headers < Hash
+    def self.parse(raw_headers)
+      headers = {}
+      raw_headers.split($/).each do |line|
+        key, value = line.chomp.split(":", 2)
+        headers[key.strip] = value.strip
+      end
+
+      new(headers)
+    end
+
+    def initialize(constructor = {})
+      if constructor.is_a?(Hash)
+        super()
+        update(constructor)
+      else
+        super(constructor)
+      end
+    end
+
+    alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+    alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+    def update(other_hash)
+      if other_hash.is_a?(Headers)
+        super(other_hash)
+      else
+        other_hash.each_pair do |key, value|
+          if block_given? && has_key?(key)
+            value = yield(convert_key(key), self[key], value)
+          end
+          self[key] = value
+        end
+        self
+      end
+    end
+
+    def [](key)
+      super(convert_key(key))
+    end
+
+    def []=(key, value)
+      regular_writer(convert_key(key), value)
+    end
+
+    alias_method :store, :[]=
+
+    def key?(key)
+      super(convert_key(key))
+    end
+
+    alias_method :include?, :key?
+    alias_method :has_key?, :key?
+    alias_method :member?, :key?
+
+    def delete(key)
+      super(convert_key(key))
+    end
+
+    private
+      def convert_key(key)
+        (key.kind_of?(Symbol) ? key.to_s.gsub(/_/, "-") : key).downcase
+      end
+  end
+end

data/lib/shoutout/metadata.rb

@@ -0,0 +1,69 @@
+class Shoutout
+  class Metadata < Hash
+    def self.parse(raw_metadata)
+      metadata = {}
+      raw_metadata.split(";").each do |key_value_pair|
+        key, value = key_value_pair.split("=", 2)
+        metadata[key] = value.match(/\A'(.*)'\z/)[1]
+      end
+
+      new(metadata)
+    end
+
+    def initialize(constructor = {})
+      if constructor.is_a?(Hash)
+        super()
+        update(constructor)
+      else
+        super(constructor)
+      end
+    end
+
+    def [](key)
+      super(convert_key(key))
+    end
+
+    def []=(key, value)
+      super(convert_key(key), value)
+    end
+
+    alias_method :store, :[]=
+
+    def key?(key)
+      super(convert_key(key))
+    end
+
+    alias_method :include?, :key?
+    alias_method :has_key?, :key?
+    alias_method :member?, :key?
+
+    def delete(key)
+      super(convert_key(key))
+    end
+
+    module QuickAccess
+      def website
+        self[:stream_url]
+      end
+
+      def now_playing
+        self[:stream_title]
+      end
+
+      def artist
+        now_playing.split(" - ")[0]
+      end
+
+      def song
+        now_playing.split(" - ")[1]
+      end
+    end
+
+    include QuickAccess
+
+    private
+      def convert_key(key)
+        key.kind_of?(Symbol) ? Util.camelize(key.to_s) : key
+      end
+  end
+end

data/lib/shoutout/quick_access.rb

@@ -0,0 +1,64 @@
+class Shoutout
+  module QuickAccess
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def content_type
+      headers[:content_type]
+    end
+
+    def audio_info
+      return @audio_info if defined?(@audio_info)
+
+      raw_audio_info = headers[:ice_audio_info]
+      return @audio_info = nil if raw_audio_info.nil?
+
+      audio_info = {}
+
+      raw_audio_info.split(";").each do |key_value_pair|
+        key, value = key_value_pair.split("=")
+        key = key.sub(/\Aice-/, "").to_sym
+        value = value.to_i
+
+        audio_info[key] = value
+      end
+
+      @audio_info = audio_info
+    end
+
+    %w(name description genre notice).each do |method|
+      define_method(method) do
+        headers["icy-#{method}"]
+      end
+    end
+
+    def bitrate
+      headers[:icy_br].to_i
+    end
+
+    def public?
+      headers[:icy_pub] == "1"
+    end
+
+    def metadata_interval
+      headers[:icy_metaint].to_i if headers[:icy_metaint]
+    end
+
+    def now_playing
+      metadata.now_playing
+    end
+
+    def website
+      metadata.website || headers[:icy_url]
+    end
+
+    module ClassMethods
+      QuickAccess.instance_methods.each do |method|
+        define_method(method) do |url|
+          new(url).send(method)
+        end
+      end
+    end
+  end
+end

data/lib/shoutout/util.rb

@@ -0,0 +1,8 @@
+class Shoutout
+  module Util
+    def self.camelize(term)
+      term = term.sub(/^[a-z\d]*/) { $&.capitalize }
+      term.gsub(/(?:_|(\/))([a-z\d]*)/) { "#{$1}#{$2.capitalize}" }
+    end
+  end
+end

data/lib/shoutout/version.rb

@@ -0,0 +1,3 @@
+class Shoutout
+  VERSION = "0.0.1"
+end

data/lib/shoutout.rb

@@ -0,0 +1,178 @@
+require "uri"
+require "socket"
+
+require "shoutout/version"
+require "shoutout/util"
+require "shoutout/metadata"
+require "shoutout/headers"
+require "shoutout/quick_access"
+
+class Shoutout
+  include QuickAccess
+
+  attr_reader :url
+
+  class << self
+    def open(url)
+      shoutcast = new(url)
+
+      begin
+        shoutcast.connect
+        yield shoutcast
+      ensure
+        shoutcast.disconnect
+      end
+    end
+
+    def metadata(url)
+      new(url).metadata
+    end
+  end
+
+  def initialize(url)
+    @url = url
+  end
+
+  def connected?
+    @connected
+  end
+
+  def connect
+    return false if @connected
+
+    uri = URI.parse(@url)
+    @socket = TCPSocket.new(uri.host, uri.port)
+    @socket.puts "GET #{uri.path} HTTP/1.0"
+    @socket.puts "Icy-MetaData: 1"
+    @socket.puts
+
+    # Read status line
+    status_line = @socket.gets
+    status_code = status_line.match(/\AHTTP\/([0-9]\.[0-9]) ([0-9]{3})/)[2].to_i
+
+    @connected = true
+
+    read_headers
+
+    if status_code >= 300 && status_code < 400 && headers[:location]
+      disconnect
+
+      @url = URI.join(uri, headers[:location]).to_s
+
+      return connect
+    end
+
+    unless status_code >= 200 && status_code < 300
+      disconnect
+
+      return false
+    end
+
+    unless metadata_interval
+      disconnect
+
+      return false
+    end
+
+    @read_metadata_thread = Thread.new(&method(:read_metadata))
+
+    true
+  end
+
+  def disconnect
+    return false unless @connected
+
+    @connected = false
+
+    @socket.close if @socket && !@socket.closed?
+    @socket = nil
+
+    true
+  end
+
+  def listen
+    return unless @connected
+
+    @read_metadata_thread.join
+    @last_metadata_change_thread.join if @last_metadata_change_thread
+  end
+
+  def metadata
+    return @metadata if defined?(@metadata)
+
+    original_metadata_change_block = @metadata_change_block
+
+    received = false
+    metadata_change do |new_metadata|
+      received = true
+    end
+
+    already_connected = @connected
+    connect unless already_connected
+
+    sleep 0.015 until received
+
+    disconnect unless already_connected
+
+    metadata_change(&original_metadata_change_block) if original_metadata_change_block
+
+    @metadata
+  end
+
+  def metadata_change(&block)
+    @metadata_change_block = block
+
+    report_metadata_change(@metadata) if defined?(@metadata)
+
+    true
+  end
+
+  private
+    def read_headers
+      raw_headers = ""
+      while line = @socket.gets
+        break if line.chomp == ""
+        raw_headers << line
+      end
+      @headers = Headers.parse(raw_headers)
+    end
+
+    def read_metadata
+      while @connected
+        # Skip audio data
+        data = @socket.read(metadata_interval) || raise(EOFError)
+
+        data = @socket.read(1) || raise(EOFError)
+        metadata_length = data.unpack("c")[0] * 16
+        next if metadata_length == 0
+
+        data = @socket.read(metadata_length) || raise(EOFError)
+        raw_metadata = data.unpack("A*")[0]
+        @metadata = Metadata.parse(raw_metadata)
+
+        report_metadata_change(@metadata)
+      end
+    rescue Errno::EBADF, IOError => e
+      # Connection lost
+      disconnect
+    end
+
+    def report_metadata_change(metadata)
+      @last_metadata_change_thread = Thread.new(metadata, @last_metadata_change_thread) do |metadata, last_metadata_change_thread|
+        last_metadata_change_thread.join if last_metadata_change_thread
+
+        @metadata_change_block.call(metadata) if @metadata_change_block
+      end
+    end
+
+    def headers
+      return @headers if defined?(@headers)
+
+      # Connected but no headers? I give up.
+      return [] if @connected
+
+      connect && disconnect
+
+      @headers
+    end
+end

data/spec/fixtures/error_response

@@ -0,0 +1,2 @@
+HTTP/1.0 404 Not Found
+

data/spec/fixtures/redirect_response

@@ -0,0 +1,3 @@
+HTTP/1.0 301 Moved Permanently
+Location: http://82.201.100.7:8000/radio538
+

data/spec/fixtures/unsupported_response

@@ -0,0 +1,3 @@
+HTTP/1.0 200 OK
+
+<strong>Unsupported</strong>

data/spec/shoutout/headers_spec.rb

@@ -0,0 +1,132 @@
+require "spec_helper"
+
+describe Shoutout::Headers do
+
+  let(:raw_headers) {
+    "Content-Type: audio/mpeg\n" <<
+      "icy-br:128\n" <<
+      "ice-audio-info: ice-samplerate=44100;ice-bitrate=128;ice-channels=2\n" <<
+      "icy-br:128\n" <<
+      "icy-description:ARE YOU IN\n" <<
+      "icy-genre:Various\n" <<
+      "icy-name:RADIO538\n" <<
+      "icy-pub:1\n" <<
+      "icy-url:http://www.radio538.nl\n" <<
+      "Server: Icecast 2.3.2-kh31\n" <<
+      "icy-metaint:16000"
+  }
+
+  let(:headers) {
+    {
+      "Content-Type"    => "audio/mpeg",
+      "icy-br"          => "128",
+      "ice-audio-info"  => "ice-samplerate=44100;ice-bitrate=128;ice-channels=2",
+      "icy-description" => "ARE YOU IN",
+      "icy-genre"       => "Various",
+      "icy-name"        => "RADIO538",
+      "icy-pub"         => "1",
+      "icy-url"         => "http://www.radio538.nl",
+      "Server"          => "Icecast 2.3.2-kh31",
+      "icy-metaint"     => "16000"
+    }
+  }
+
+  subject { described_class.new(headers) }
+
+  describe ".parse" do
+
+    it "parses the headers" do
+      described_class.should_receive(:new).with(headers)
+
+      described_class.parse(raw_headers)
+    end
+  end
+
+  describe "#initialize" do
+
+    context "when provided a Hash" do
+
+      it "updates self with the Hash" do
+        described_class.any_instance.should_receive(:update).with(headers)
+
+        described_class.new(headers)
+      end
+    end
+  end
+
+  describe "#[]" do
+
+    context "when provided a Symbol" do
+
+      context "when the header's key was originally camel cased" do
+
+        it "returns the header's value" do
+          subject[:content_type].should eq(headers["Content-Type"])
+        end
+      end
+
+      context "when the header's key was originally lowercase" do
+
+        it "returns the header's value" do
+          subject[:Icy_Br].should eq(headers["icy-br"])
+        end
+      end
+    end
+
+    context "when provided a String" do
+
+      context "when the header's key was originally camel cased" do
+
+        it "returns the header's value" do
+          subject["content-type"].should eq(headers["Content-Type"])
+        end
+      end
+
+      context "when the header's key was originally lowercase" do
+
+        it "returns the header's value" do
+          subject["Icy-Br"].should eq(headers["icy-br"])
+        end
+      end
+    end
+  end
+
+  describe "#[]=" do
+
+    let(:content_type) { "text/plain" }
+
+    context "when provided a Symbol key" do
+
+      it "is saved on the hash" do
+        subject[:content_type] = content_type
+
+        subject.should have_key(:content_type)
+      end
+
+      it "can be read out again" do
+        subject[:content_type] = content_type
+
+        subject[:content_type].should eq(content_type)
+        subject["content-type"].should eq(content_type)
+        subject["Content-Type"].should eq(content_type)
+      end
+    end
+
+    context "when provided a String key" do
+
+      it "is saved on the hash" do
+        subject["content-type"] = content_type
+
+        subject.should have_key("content-type")
+      end
+
+      it "can be read out again" do
+        subject["content-type"] = content_type
+
+        subject[:content_type].should eq(content_type)
+        subject["content-type"].should eq(content_type)
+        subject["Content-Type"].should eq(content_type)
+      end
+    end
+  end
+end

data/spec/shoutout/metadata_spec.rb

@@ -0,0 +1,90 @@
+require "spec_helper"
+
+describe Shoutout::Metadata do
+
+  let(:raw_metadata) { "StreamTitle='ARMIN VAN BUUREN - THIS IS WHAT IT FEELS LIKE';StreamUrl='http://www.radio538.nl';" }
+
+  let(:metadata) {
+    {
+      "StreamTitle" => "ARMIN VAN BUUREN - THIS IS WHAT IT FEELS LIKE",
+      "StreamUrl"   => "http://www.radio538.nl"
+    }
+  }
+
+  subject { described_class.new(metadata) }
+
+  describe ".parse" do
+
+    it "parses the metadata" do
+      described_class.should_receive(:new).with(metadata)
+
+      described_class.parse(raw_metadata)
+    end
+  end
+
+  describe "#initialize" do
+
+    context "when provided a Hash" do
+
+      it "updates self with the Hash" do
+        described_class.any_instance.should_receive(:update).with(metadata)
+
+        described_class.new(metadata)
+      end
+    end
+  end
+
+  describe "#[]" do
+
+    context "when provided a Symbol" do
+
+      it "returns the metadata" do
+        subject[:stream_title].should eq(metadata["StreamTitle"])
+      end
+    end
+
+    context "when provided a String" do
+
+      it "returns the header's value" do
+        subject["StreamTitle"].should eq(metadata["StreamTitle"])
+      end
+    end
+  end
+
+  describe "#[]=" do
+
+    let(:stream_title) { "AVICII - WAKE ME UP" }
+
+    context "when provided a Symbol key" do
+
+      it "is saved on the hash" do
+        subject[:stream_title] = stream_title
+
+        subject.should have_key(:stream_title)
+      end
+
+      it "can be read out again" do
+        subject[:stream_title] = stream_title
+
+        subject[:stream_title].should eq(stream_title)
+        subject["StreamTitle"].should eq(stream_title)
+      end
+    end
+
+    context "when provided a String key" do
+
+      it "is saved on the hash" do
+        subject["StreamTitle"] = stream_title
+
+        subject.should have_key("StreamTitle")
+      end
+
+      it "can be read out again" do
+        subject["StreamTitle"] = stream_title
+
+        subject[:stream_title].should eq(stream_title)
+        subject["StreamTitle"].should eq(stream_title)
+      end
+    end
+  end
+end

data/spec/shoutout/quick_access_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+
+describe Shoutout::QuickAccess do
+
+  let(:url) { "http://82.201.100.5:8000/radio538" }
+  subject   { Shoutout.new(url) }
+
+  describe "#audio_info" do
+
+    let(:raw_audio_info) { "ice-samplerate=44100;ice-bitrate=128;ice-channels=2" }
+    let(:audio_info) {
+      {
+        samplerate: 44100,
+        bitrate:    128,
+        channels:   2
+      }
+    }
+
+    before(:each) do
+      subject.stub(:headers).and_return(Shoutout::Headers.new("ice-audio-info" => raw_audio_info))
+    end
+
+    it "returns the parsed metadata" do
+      subject.audio_info.should eq(audio_info)
+    end
+  end
+
+  describe ".name" do
+
+    it "creates a new instance" do
+      Shoutout.should_receive(:new).with(url).and_return(double("shoutout").as_null_object)
+
+      Shoutout.name(url)
+    end
+
+    it "calls #name on the opened connection" do
+      Shoutout.any_instance.should_receive(:name)
+
+      Shoutout.name(url)
+    end
+  end
+end

data/spec/shoutout/util_spec.rb

@@ -0,0 +1,11 @@
+require "spec_helper"
+
+describe Shoutout::Util do
+
+  describe ".camelize" do
+
+    it "camelizes the passed string" do
+      described_class.camelize("under_score").should eq("UnderScore")
+    end
+  end
+end

data/spec/shoutout_spec.rb

@@ -0,0 +1,289 @@
+require "spec_helper"
+
+describe Shoutout do
+
+  let(:url)           { "http://82.201.100.5:8000/radio538" }
+  let(:uri)           { URI.parse(url) }
+  subject!            { described_class.new(url) }
+  let(:response_data) { File.read(File.expand_path("../fixtures/ok_response", __FILE__)) }
+  let(:socket)        { FakeTCPSocket.new(response_data) }
+
+  before(:each) do
+    TCPSocket.stub(:new).with(uri.host, uri.port).and_return(socket)
+
+    described_class.stub(:new).with(url).and_return(subject)
+  end
+
+  after(:each) do
+    subject.disconnect
+  end
+
+  describe ".open" do
+
+    let(:block) { lambda { |_| } }
+
+    it "creates a new instance" do
+      described_class.should_receive(:new).with(url)
+
+      described_class.open(url, &block)
+    end
+
+    it "opens a connection" do
+      subject.should_receive(:connect)
+
+      described_class.open(url, &block)
+    end
+
+    it "calls the block" do
+      expect { |block|
+        described_class.open(url, &block)
+      }.to yield_with_args(subject)
+    end
+
+    it "closes the connection" do
+      subject.should_receive(:disconnect).twice.and_call_original
+
+      described_class.open(url, &block)
+    end
+  end
+
+  describe ".metadata" do
+
+    it "creates a new instance" do
+      described_class.should_receive(:new).with(url)
+
+      described_class.metadata(url)
+    end
+
+    it "calls #metadata on the opened connection" do
+      subject.should_receive(:metadata)
+
+      described_class.metadata(url)
+    end
+  end
+
+  describe "#connect" do
+
+    context "when already connected" do
+
+      before(:each) do
+        subject.connect
+      end
+
+      it "returns false" do
+        subject.connect.should be_false
+      end
+    end
+
+    context "when not connected" do
+
+      it "connects" do
+        subject.connect 
+
+        subject.should be_connected
+      end
+
+      it "opens a socket" do
+        TCPSocket.should_receive(:new).with(uri.host, uri.port)
+
+        subject.connect
+      end
+
+      it "writes the HTTP request to the socket" do
+        socket.should_receive(:puts).once.ordered.with("GET #{uri.path} HTTP/1.0")
+        socket.should_receive(:puts).once.ordered.with("Icy-MetaData: 1")
+        socket.should_receive(:puts).once.ordered.with(no_args)
+
+        subject.connect
+      end
+
+      it "reads the headers" do
+        subject.connect
+
+        subject.metadata_interval.should eq(10)
+      end
+
+      context "when the response indicates a redirect" do
+
+        let(:redirect_response_data)  { File.read(File.expand_path("../fixtures/redirect_response", __FILE__)) }
+        let(:redirect_socket)         { FakeTCPSocket.new(redirect_response_data) }
+
+        before(:each) do
+          TCPSocket.stub(:new).with(uri.host, uri.port).and_return(redirect_socket)
+          TCPSocket.stub(:new).with("82.201.100.7", 8000).and_return(socket)
+        end
+
+        it "closes the connection" do
+          subject.should_receive(:disconnect).twice.and_call_original
+
+          subject.connect
+        end
+
+        it "updates the url" do
+          subject.connect
+
+          subject.url.should eq("http://82.201.100.7:8000/radio538")
+        end
+
+        it "opens a second connection" do
+          subject.should_receive(:connect).twice.and_call_original
+
+          subject.connect
+        end
+
+        it "returns true" do
+          subject.connect.should be_true
+        end
+      end
+
+      context "when the response indicates an error" do
+
+        let(:response_data) { File.read(File.expand_path("../fixtures/error_response", __FILE__)) }
+
+        it "closes the connection" do
+          subject.should_receive(:disconnect).twice.and_call_original
+
+          subject.connect
+        end
+
+        it "returns false" do
+          subject.connect.should be_false
+        end
+      end
+
+      context "when the response indicates success" do
+
+        context "when the response is unsupported" do
+
+          let(:response_data) { File.read(File.expand_path("../fixtures/unsupported_response", __FILE__)) }
+
+          it "closes the connection" do
+            subject.should_receive(:disconnect).twice.and_call_original
+
+            subject.connect
+          end
+
+          it "returns false" do
+            subject.connect.should be_false
+          end
+        end
+
+        context "when the response is supported" do
+
+          it "starts reading metadata in a thread" do
+            Thread.should_receive(:new)
+
+            subject.connect
+          end
+
+          it "returns true" do
+            subject.connect.should be_true
+          end
+        end
+      end
+    end
+  end
+
+  describe "#disconnect" do
+
+    context "when connected" do
+
+      before(:each) do
+        subject.connect
+      end
+
+      it "disconnects" do
+        subject.disconnect 
+        
+        subject.should_not be_connected
+      end
+
+      it "closes the socket" do
+        socket.should_receive(:close)
+
+        subject.disconnect
+      end
+
+      it "returns true" do
+        subject.disconnect.should be_true
+      end
+    end
+
+    context "when not connected" do
+
+      it "returns false" do
+        subject.disconnect.should be_false
+      end
+    end
+  end
+
+  describe "#listen" do
+
+    context "when connected" do
+
+      before(:each) do
+        subject.connect
+      end
+
+      after(:each) do
+        subject.disconnect
+      end
+
+      it "joins the metadata reading thread" do
+        Thread.any_instance.should_receive(:join)
+
+        subject.listen
+      end
+    end
+  end
+
+  describe "#metadata" do
+
+    context "when connected" do
+
+      before(:each) do
+        subject.connect
+      end
+
+      it "returns the metadata" do
+        subject.metadata.now_playing.should eq("AVICII - WAKE ME UP")
+      end
+    end
+
+    context "when not connected" do
+
+      it "opens a connection" do
+        subject.should_receive(:connect).and_call_original
+
+        subject.metadata
+      end
+
+      it "closes the connection" do
+        subject.should_receive(:disconnect).at_least(2).times.and_call_original
+
+        subject.metadata
+      end
+
+      it "returns the metadata" do
+        subject.metadata.now_playing.should eq("AVICII - WAKE ME UP")
+      end
+    end
+  end
+
+  describe "#metadata_change" do
+
+    it "sets a block that is called when the metadata changes" do
+      metadatas = []
+
+      subject.metadata_change do |metadata|
+        metadatas << metadata
+      end
+
+      subject.connect
+      subject.listen
+
+      metadatas[0].now_playing.should eq("ARMIN VAN BUUREN - THIS IS WHAT IT FEELS LIKE")
+      metadatas[1].now_playing.should eq("AVICII - WAKE ME UP")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+
+require "rspec"
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+require "shoutout"

data/spec/support/fake_tcp_socket.rb

@@ -0,0 +1,20 @@
+require "stringio"
+
+class FakeTCPSocket < StringIO
+
+  def <<(*args)
+    # noop
+  end
+
+  def puts(*args)
+    # noop
+  end
+  
+  def print(*args)
+    # noop
+  end
+  
+  def printf(*args)
+    # noop
+  end
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: shoutout
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Douwe Maan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70299652575840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70299652575840
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70299652591920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70299652591920
+description: A Ruby library for easily getting metadata from Shoutcast-compatible
+  audio streaming servers
+email: douwe@selenight.nl
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/shoutout/headers.rb
+- lib/shoutout/metadata.rb
+- lib/shoutout/quick_access.rb
+- lib/shoutout/util.rb
+- lib/shoutout/version.rb
+- lib/shoutout.rb
+- LICENSE
+- README.md
+- Rakefile
+- Gemfile
+- spec/fixtures/error_response
+- spec/fixtures/ok_response
+- spec/fixtures/redirect_response
+- spec/fixtures/unsupported_response
+- spec/shoutout/headers_spec.rb
+- spec/shoutout/metadata_spec.rb
+- spec/shoutout/quick_access_spec.rb
+- spec/shoutout/util_spec.rb
+- spec/shoutout_spec.rb
+- spec/spec_helper.rb
+- spec/support/fake_tcp_socket.rb
+homepage: https://github.com/DouweM/shoutout
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 848854510650494207
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 848854510650494207
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Read metadata from Shoutcast streams
+test_files:
+- spec/fixtures/error_response
+- spec/fixtures/ok_response
+- spec/fixtures/redirect_response
+- spec/fixtures/unsupported_response
+- spec/shoutout/headers_spec.rb
+- spec/shoutout/metadata_spec.rb
+- spec/shoutout/quick_access_spec.rb
+- spec/shoutout/util_spec.rb
+- spec/shoutout_spec.rb
+- spec/spec_helper.rb
+- spec/support/fake_tcp_socket.rb