hallon 0.0.0 → 0.1.0

data/lib/hallon/synchronizable.rb

@@ -0,0 +1,32 @@
+# coding: utf-8
+require 'monitor'
+require 'forwardable'
+
+module Hallon
+  # Adds synchronization primitives to target when included.
+  module Synchronizable
+    # Creates a `Monitor` for the target instance and adds `monitor` class method for access.
+    #
+    # Also adds several other methods:
+    #
+    # - `#synchronize`
+    # - `#new_cond`
+    #
+    # These all delegate to `#monitor`.
+    #
+    # @note This module is part of Hallons private API
+    # @private
+    def self.included(o)
+      o.instance_exec do
+        @monitor = Monitor.new
+        class << self
+          attr_reader :monitor
+        end
+      end
+    end
+
+    extend Forwardable
+    def_delegators :monitor, :synchronize, :new_cond
+    def_delegators 'self.class', :monitor
+  end
+end

data/lib/hallon/user.rb

@@ -0,0 +1,69 @@
+# coding: utf-8
+module Hallon
+  # Users are the entities that interact with the Spotify service.
+  #
+  # Methods are available for retrieving metadata and relationship
+  # status between users.
+  #
+  # @see http://developer.spotify.com/en/libspotify/docs/group__user.html
+  class User
+    extend Linkable
+
+    # @macro [attach] from_link
+    #   Given a Link, get its’ underlying pointer.
+    #
+    #   @method to_link
+    #   @scope  class
+    #   @param  [String, Hallon::Link, FFI::Pointer] link
+    #   @return [FFI::Pointer]
+    from_link(:profile) { |link| Spotify::link_as_user(link) }
+
+    # @macro [attach] to_link
+    #   Create a Link to the current object.
+    #
+    #   @method to_link
+    #   @scope  instance
+    #   @return [Hallon::Link]
+    to_link(:user)
+
+    # Used by {Session#relation_type?}
+    attr_reader :pointer
+
+    # Construct a new instance of User.
+    #
+    # @param [String, Link, FFI::Pointer] link
+    def initialize(link)
+      @pointer = Spotify::Pointer.new from_link(link), :user, true
+    end
+
+    # @return [Boolean] true if the user is loaded
+    def loaded?
+      Spotify::user_is_loaded(@pointer)
+    end
+
+    # Retrieve the name of the current user.
+    #
+    # @note Unless the user is {User#loaded?} only the canonical name is accessible
+    # @param [Symbol] type one of :canonical, :display, :full
+    # @return [String]
+    def name(type = :canonical)
+      case type
+      when :display
+        Spotify::user_display_name(@pointer)
+      when :full
+        Spotify::user_full_name(@pointer)
+      when :canonical
+        Spotify::user_canonical_name(@pointer)
+      else
+        raise ArgumentError, "expected type to be :display, :full or :canonical, but was #{type}"
+      end.to_s
+    end
+
+    # Retrieve the URL to the users’ profile picture.
+    #
+    # @return [String]
+    def picture
+      Spotify::user_picture(@pointer).to_s
+    end
+  end
+end

data/lib/hallon/version.rb

@@ -0,0 +1,7 @@
+# coding: utf-8
+module Hallon
+  # Current release version of Hallon
+  #
+  # @see http://semver.org/
+  VERSION = [0, 1, 0].join('.')
+end

data/spec/fixtures/example_uris.rb

@@ -0,0 +1,11 @@
+def example_uris
+  {
+    "spotify:search:omg%2bwtf%2b%ef%a3%bf%c3%9f%e2%88%82%2bbbq" => :search,
+    "spotify:track:3oN2Kq1h07LSSBSLYQp0Ns" => :track,
+    "spotify:album:6I58XCEkOnfUVsfpDehzlQ" => :album,
+    "spotify:artist:6MF9fzBmfXghAz953czmBC" => :artist,
+    "spotify:user:burgestrand:playlist:4nQnbGi4kALbME9csEqdW2" => :playlist,
+    "spotify:user:burgestrand" => :profile,
+    "spotify:user:burgestrand:starred" => :starred,
+  }
+end

data/spec/hallon/error_spec.rb

@@ -0,0 +1,30 @@
+describe Hallon::Error do
+  subject { described_class }
+  
+  it { should <= RuntimeError }
+  
+  describe "::disambiguate" do
+    it "should not fail on invalid numbers" do
+      subject.disambiguate(10000).should eq [-1, nil]
+    end
+    
+    it "should not fail on invalid symbols" do
+      subject.disambiguate(:fail).should eq [-1, nil]
+    end
+  end
+  
+  describe "::explain" do
+    it { subject.explain(0).should eq 'No error' }
+    it { subject.explain(-1).should eq 'invalid error code' }
+  end
+  
+  describe "::maybe_raise" do
+    it "should not raise error when given 0 as error code" do
+      expect { subject.maybe_raise(0) }.to_not raise_error
+    end
+    
+    it "should raise error when given non-0 as error code" do
+      expect { subject.maybe_raise(1) }.to raise_error(Hallon::Error)
+    end
+  end
+end

data/spec/hallon/ffi_spec.rb

@@ -0,0 +1,5 @@
+describe FFI::Pointer do
+  it "should have a #read_size_t" do
+    described_class.instance_methods.should include :read_size_t
+  end
+end

data/spec/hallon/hallon_spec.rb

@@ -0,0 +1,16 @@
+describe Hallon do
+  describe "VERSION" do
+    specify { Hallon::VERSION.should == "0.0.0" }
+  end
+
+  describe "API_VERSION" do
+    specify { Hallon::API_VERSION.should == 8 }
+  end
+
+  describe "URI" do
+    subject { Hallon::URI }
+    example_uris.keys.each do |uri|
+      it { should match uri }
+    end
+  end
+end

data/spec/hallon/image_spec.rb

@@ -0,0 +1,41 @@
+# coding: utf-8
+describe Hallon::Image, :logged_in => true do
+  context "created from a Spotify URI" do
+    before(:all) do
+      @uri   = "spotify:image:3ad93423add99766e02d563605c6e76ed2b0e450"
+      @image = Hallon::Image.new @uri
+      @image.status.should eq :is_loading
+      session.process_events_on { @image.loaded? }
+    end
+
+    subject { @image }
+
+    its(:status) { should be :ok }
+    its(:format) { should be :jpeg }
+
+    specify "its #id should match its’ spotify uri" do
+      @uri.should match @image.id
+    end
+
+    describe "#data" do
+      it "should correspond to the fixture image" do
+        @image.data.should eq File.read(fixture_image_path, :encoding => 'binary')
+      end
+
+      it "should have a binary encoding" do
+        @image.data.encoding.name.should eq 'ASCII-8BIT'
+      end
+    end
+  end
+
+  describe "callbacks" do
+    it "should trigger :load when loaded" do
+      uri = "spotify:image:c78f091482e555bd2ffacfcd9cbdc0714b221663"
+      image = Hallon::Image.new(uri)
+      image.should_not be_loaded
+      image.should_receive(:trigger).with(:load).once
+
+      session.process_events_on { image.loaded? }
+    end
+  end
+end

data/spec/hallon/link_spec.rb

@@ -0,0 +1,84 @@
+describe Hallon::Link, :session => true do
+  subject { Hallon::Link.new("spotify:user:burgestrand") }
+
+  context "class methods" do
+    subject { described_class }
+
+    describe "::new" do
+      it "should raise an ArgumentError on an invalid link" do
+        expect { subject.new("omgwtfbbq") }.to raise_error(ArgumentError, /omgwtfbbq/)
+      end
+
+      it "should not raise error on valid links" do
+        expect { subject.new("spotify:user:burgestrand") }.to_not raise_error
+      end
+
+      it "should accept an FFI pointer" do
+        expect { subject.new FFI::Pointer.new(0) }.to raise_error(ArgumentError, /is not a valid Spotify link/)
+      end
+
+      it "should not initialize when given a Link" do
+        link = subject.new('spotify:user:burgestrand')
+        link.should_not_receive :to_str
+        subject.new link
+      end
+    end
+
+    describe "::valid?" do
+      it "should be true for a valid link" do
+        subject.valid?("spotify:user:burgestrand").should be_true
+      end
+
+      it "should be false for an invalid link" do
+        subject.valid?("omgwtfbbq").should be_false
+      end
+    end
+  end
+
+  describe "#to_str" do
+    it "should return the Spotify URI as a string" do
+      subject.to_str.should == "spotify:user:burgestrand"
+    end
+
+    it "should truncate if given a small maximum length" do
+      subject.to_str(7).should == "spotify"
+    end
+  end
+
+  describe "#to_url" do
+    it "should return the correct http URL" do
+      subject.to_url.should == "http://open.spotify.com/user/burgestrand"
+    end
+  end
+
+  describe "#length" do
+    it { subject.length.should == "spotify:user:burgestrand".length }
+  end
+
+  describe "#type" do
+    example_uris.each_pair do |uri, type|
+      specify "#{uri} should equal #{type}" do
+        Hallon::Link.new(uri).type.should equal type
+      end
+    end
+  end
+
+  describe "#to_s" do
+    it("should include the Spotify URI") do
+      subject.to_s.should include subject.to_str
+    end
+  end
+
+  describe "#==" do
+    it "should compare using #to_str" do
+      obj = Object.new
+      obj.should_receive(:to_str).and_return(subject.to_str)
+
+      subject.should eq obj
+    end
+
+    it "should not fail when #to_str is unavailable" do
+      subject.should_not eq Object.new
+    end
+  end
+end

data/spec/hallon/linkable_spec.rb

@@ -0,0 +1,43 @@
+describe Hallon::Linkable do
+  it "should define the #from_link method" do
+    klass = Class.new
+    klass.should_not respond_to :from_link
+
+    klass.instance_exec do
+      extend Hallon::Linkable
+      from_link :foobar
+    end
+
+    klass.should respond_to :from_link
+  end
+
+  describe "#from_link" do
+    it "should call the given block if necessary" do
+      called = false
+      klass = Class.new
+
+      klass.instance_exec do
+        extend Hallon::Linkable
+        from_link(nil) { called = true }
+      end
+
+      klass.from_link("spotify:search:whatever")
+      called.should eq true
+    end
+
+    it "should pass extra parameters to the defining block" do
+      klass = Class.new
+
+      link = mock
+      link.stub(:pointer)
+      Hallon::Link.stub(:new => link)
+
+      klass.instance_exec do
+        extend Hallon::Linkable
+        from_link(nil) { |link, *args| args }
+      end
+
+      klass.from_link("spotify:user:burgestrand", :cool, 5).should eq [:cool, 5]
+    end
+  end
+end

data/spec/hallon/observable_spec.rb

@@ -0,0 +1,103 @@
+describe Hallon::Observable do
+  subject do
+    Class.new { include Hallon::Observable }.new
+  end
+
+  describe "instance methods" do
+    subject { described_class.instance_methods }
+
+    it { should include :on }
+    it { should include :trigger }
+  end
+
+  describe "#on" do
+    it "should allow defining one handler for multiple events" do
+      subject.on(:a, :b, :c) do |event, *args|
+        "yay"
+      end
+
+      subject.trigger(:a).should eq "yay"
+      subject.trigger(:b).should eq "yay"
+      subject.trigger(:c).should eq "yay"
+    end
+
+    specify "a multi-declared handler should know its name" do
+      subject.on(:a, :b) { |event, *args| event }
+      subject.trigger(:a).should eq :a
+      subject.trigger(:b).should eq :b
+    end
+
+    specify "a single-declared handler should not know its name" do
+      subject.on(:a) { |event, *args| event }
+      subject.trigger(:a).should eq nil
+    end
+  end
+
+  describe "#trigger and #on" do
+    it "should define and call event handlers" do
+      called = false
+      subject.on(:a) { called = true }
+      subject.trigger(:a)
+      called.should be_true
+    end
+
+    it "should pass any arguments to handlers" do
+      passed_args = []
+      subject.on(:a) { |*args| passed_args = args }
+      subject.trigger(:a, :b, :c)
+      passed_args.should eq [:b, :c]
+    end
+
+    it "should do nothing when there are no handlers" do
+      subject.trigger(:this_event_does_not_exist).should be_nil
+    end
+
+    context "multiple handlers" do
+      it "should call all handlers in order" do
+        triggered = []
+        subject.on(:a) { triggered << :a }
+        subject.on(:a) { triggered << :b }
+        subject.trigger(:a)
+        triggered.should eq [:a, :b]
+      end
+
+      it "should return the last-returned value" do
+        subject.on(:a) { :first }
+        subject.on(:a) { :second }
+        subject.trigger(:a).should eq :second
+      end
+
+      it "should allow execution to be aborted" do
+        subject.on(:a) { throw :return, :first }
+        subject.on(:b) { :second }
+        subject.trigger(:a).should eq :first
+      end
+    end
+  end
+
+  describe "#protecting_handlers" do
+    it "should call the given block, returning the result" do
+      was_called = false
+      subject.protecting_handlers { was_called = true }.should be_true
+      was_called.should be_true
+    end
+
+    it "should restore previous handlers on return" do
+      subject.on(:protected) { "before" }
+
+      subject.protecting_handlers do
+        subject.trigger(:protected).should eq "before"
+        subject.on(:protected) { "after" }
+        subject.trigger(:protected).should eq "after"
+      end
+
+      subject.trigger(:protected).should eq "before"
+    end
+
+    it "should still allow #trigger to work on non-defined events" do
+      subject.protecting_handlers {}
+      expect { subject.trigger(:does_not_exist) }.to_not raise_error
+    end
+  end
+
+end