hallon 0.9.0 → 0.9.1

data/CHANGELOG

@@ -1,6 +1,22 @@
 Hallon’s Changelog
 ==================
 
+v0.9.1
+------------------
+[ Added ]
+- PlaylistContainer#size
+- User#published
+- PlaylistContainer#contents (only for playlists)
+- PlaylistContainer#add (existing playlist, new playlist)
+
+[ Changed ]
+- Playlist#seen now moved to Playlist::Track#seen=
+
+[ Fixed ]
+- Album#cover null pointer issue (https://github.com/Burgestrand/Hallon/issues/53)
+- Various possible null pointer bugs
+
+
 v0.9.0
 ------------------
 - Upgraded to libspotify *v10*

data/lib/hallon/album.rb

@@ -83,11 +83,11 @@ module Hallon
     # @return [Image, Link, nil] album cover, the link to it, or nil.
     def cover(as_image = true)
       if as_image
-        image_id = Spotify.album_cover(pointer)
-        Image.new(image_id.read_string(20)) unless image_id.null?
+        cover = Spotify.album_cover(pointer)
+        Image.new cover.read_string(20) unless cover.null?
       else
-        link = Spotify.link_create_from_album_cover!(pointer)
-        Link.new(link)
+        cover = Spotify.link_create_from_album_cover!(pointer)
+        Link.new cover unless cover.null?
       end
     end
 

data/lib/hallon/album_browse.rb

@@ -24,6 +24,8 @@ module Hallon
 
       @callback = proc { trigger(:load) }
       @pointer  = Spotify.albumbrowse_create!(session.pointer, pointer, @callback, nil)
+
+      raise FFI::NullPointerError, "album browsing failed" if @pointer.null?
     end
 
     # @return [Boolean] true if the album browser is loaded.
@@ -75,7 +77,7 @@ module Hallon
       size = Spotify.albumbrowse_num_tracks(pointer)
       Enumerator.new(size) do |i|
         track = Spotify.albumbrowse_track!(pointer, i)
-        Track.new(track) unless track.null?
+        Track.new(track)
       end
     end
   end

data/lib/hallon/artist.rb

@@ -49,10 +49,10 @@ module Hallon
     def portrait(as_image = true)
       if as_image
         portrait = Spotify.artist_portrait(pointer)
-        Image.new(portrait.read_bytes(20)) unless portrait.null?
+        Image.new portrait.read_bytes(20) unless portrait.null?
       else
         portrait = Spotify.link_create_from_artist_portrait!(pointer)
-        Link.new(portrait) unless portrait.null?
+        Link.new portrait unless portrait.null?
       end
     end
 

data/lib/hallon/artist_browse.rb

@@ -28,6 +28,8 @@ module Hallon
 
       @callback = proc { trigger(:load) }
       @pointer  = Spotify.artistbrowse_create!(session.pointer, pointer, type, @callback, nil)
+
+      raise FFI::NullPointerError, "artist browsing failed" if @pointer.null?
     end
 
     # @return [Boolean] true if the artist browser is loaded.

data/lib/hallon/linkable.rb

@@ -65,15 +65,11 @@ module Hallon
       type    = as_object.to_s[/^(as_)?([^_]+)/, 2].to_sym
 
       define_method(:from_link) do |link, *args|
-        if link.is_a?(FFI::Pointer) and not link.is_a?(Spotify::Pointer)
-          link
-        else
-          unless Spotify::Pointer.typechecks?(link, :link)
-            link = Link.new(link).pointer(type)
-          end
-
-          instance_exec(link, *args, &block)
+        unless Spotify::Pointer.typechecks?(link, :link)
+          link = Link.new(link).pointer(type)
         end
+
+        instance_exec(link, *args, &block)
       end
 
       private :from_link
@@ -94,11 +90,11 @@ module Hallon
     #   end
     #
     # @param [Symbol] cmethod name of the C method, say `from_artist` in `Spotify.link_create_from_artist`.
-    # @return [Link]
+    # @return [Link, nil]
     def to_link(cmethod)
       define_method(:to_link) do |*args|
         link = Spotify.__send__(:"link_create_#{cmethod}!", pointer, *args)
-        Link.new(link)
+        Link.new(link) unless link.null?
       end
     end
 

data/lib/hallon/playlist.rb

@@ -17,15 +17,16 @@ module Hallon
     # There is no way to refresh the information. You’ll have to retrieve the
     # track again.
     class Track < Hallon::Track
-      def initialize(playlist, index)
-        super Spotify.playlist_track!(playlist, index)
+      def initialize(pointer, playlist, index)
+        super(pointer)
 
         @index       = index
-        @create_time = Time.at Spotify.playlist_track_create_time(playlist, index)
-        @message     = Spotify.playlist_track_message(playlist, index)
-        @seen        = Spotify.playlist_track_seen(playlist, index)
+        @playlist    = playlist
+        @create_time = Time.at Spotify.playlist_track_create_time(playlist.pointer, index)
+        @message     = Spotify.playlist_track_message(playlist.pointer, index)
+        @seen        = Spotify.playlist_track_seen(playlist.pointer, index)
         @creator     = begin
-          creator = Spotify.playlist_track_creator!(playlist, index)
+          creator = Spotify.playlist_track_creator!(playlist.pointer, index)
           User.new(creator) unless creator.null?
         end
       end
@@ -34,26 +35,42 @@ module Hallon
       # @return [Integer] index this track was created with.
       attr_reader :index
 
+      # @return [Playlist] playlist this track was created from.
+      attr_reader :playlist
+
       # @return [Time] time when track at {#index} was added to playlist.
-      def create_time
-        @create_time
-      end
+      attr_reader :create_time
 
       # @return [User, nil] person who added track at {#index} to this playlist.
-      def creator
-        @creator
-      end
+      attr_reader :creator
 
       # @return [String] message attached to this track at {#index}.
-      def message
-        @message
-      end
+      attr_reader :message
 
       # @see Playlist#seen
       # @return [Boolean] true if track at {#index} has been seen.
       def seen?
         @seen
       end
+
+      # Set seen status of the Playlist::Track at the given index.
+      #
+      # @note Word of warning; this method will update the value you get from {#seen?}!
+      # @raise [IndexError] if the underlying track has moved
+      # @raise [Error] if the operation could not be completed
+      #
+      # @param [Integer] index
+      # @param [Boolean] seen true if the track is now seen
+      # @return [Playlist::Track] track at the given index
+      def seen=(seen)
+        unless Spotify.playlist_track(playlist.pointer, index) == pointer
+          raise IndexError, "track has moved from #{index}"
+        end
+
+        error = Spotify.playlist_track_set_seen(playlist.pointer, index, !! seen)
+        Error.maybe_raise(error)
+        @seen = Spotify.playlist_track_seen(playlist.pointer, index)
+      end
     end
 
     from_link :playlist do |pointer|
@@ -176,16 +193,19 @@ module Hallon
     #       libspotify does not store more than 500 subscriber names
     # @return [Array<String>] list of canonical usernames
     def subscribers
-      ptr    = Spotify.playlist_subscribers(pointer)
-      struct = Spotify::Subscribers.new(ptr)
+      ptr = Spotify.playlist_subscribers(pointer)
 
-      if struct[:count].zero?
-        []
-      else
-        struct[:subscribers].map(&:read_string)
-      end
-    ensure
-      Spotify.playlist_subscribers_free(ptr)
+      begin
+        struct = Spotify::Subscribers.new(ptr)
+
+        if struct[:count].zero?
+          []
+        else
+          struct[:subscribers].map(&:read_string)
+        end
+      ensure
+        Spotify.playlist_subscribers_free(ptr)
+      end unless ptr.null?
     end
 
     # @return [Integer] total number of subscribers.
@@ -223,20 +243,10 @@ module Hallon
     #
     # @return [Enumerable<Playlist::Track>] a list of playlist tracks.
     def tracks
-      Enumerator.new(size) { |i| Playlist::Track.new(pointer, i) }
-    end
-
-    # Set seen status of the Playlist::Track at the given index.
-    #
-    # @see #tracks
-    # @raise [Error] if the operation could not be completed
-    # @param [Integer] index
-    # @param [Boolean] seen true if the track is now seen
-    # @return [Playlist::Track] track at the given index
-    def seen(index, seen)
-      error = Spotify.playlist_track_set_seen(pointer, index, !! seen)
-      Error.maybe_raise(error)
-      tracks[index]
+      Enumerator.new(size) do |index|
+        track = Spotify.playlist_track!(pointer, index)
+        Playlist::Track.new(track, self, index) unless track.null?
+      end
     end
 
     # Add a list of tracks to the playlist starting at given position.

data/lib/hallon/playlist_container.rb

@@ -13,15 +13,59 @@ module Hallon
       @pointer = to_pointer(pointer, :playlistcontainer)
     end
 
-    # @return [Boolean] true if the container is loaded
+    # @return [Boolean] true if the container is loaded.
     def loaded?
       Spotify.playlistcontainer_is_loaded(pointer)
     end
 
-    # @return [User, nil] owner of the container (nil if unknown or no owner)
+    # @return [User, nil] owner of the container (nil if unknown or no owner).
     def owner
       owner = Spotify.playlistcontainer_owner!(pointer)
       User.new(owner) unless owner.null?
     end
+
+    # @return [Integer] number of playlists and folders in this container.
+    def size
+      Spotify.playlistcontainer_num_playlists(pointer)
+    end
+
+    # @return [Enumerator<Playlist, Folder, nil>] an enumerator of folders and playlists.
+    def contents
+      Enumerator.new(size) do |i|
+        type = Spotify.playlistcontainer_playlist_type(pointer, i)
+
+        case type
+        when :playlist
+          playlist = Spotify.playlistcontainer_playlist!(pointer, i)
+          Playlist.new(playlist)
+        when :start_folder
+        when :end_folder
+        else # :unknown
+        end
+      end
+    end
+
+    # @overload add(name)
+    #   Create a new playlist at the end of the container with the given name.
+    #
+    #   @param [String] name
+    #   @return [Playlist, nil] the new playlist, or nil if the operation failed
+    #
+    # @overload add(playlist)
+    #   Add the given playlist to the end of the container.
+    #
+    #   @param [Playlist, Link, #to_link] playlist
+    #   @return [Playlist, nil] the added playlist, or nil if the operation failed
+    def add(name_or_playlist)
+      playlist = if name_or_playlist.is_a?(String)
+        Spotify.playlistcontainer_add_new_playlist!(pointer, name_or_playlist)
+      else
+        link = name_or_playlist
+        link = link.to_link unless link.is_a?(Link)
+        Spotify.playlistcontainer_add_playlist!(pointer, link.pointer)
+      end
+
+      Playlist.new(playlist) unless playlist.null?
+    end
   end
 end

data/lib/hallon/user.rb

@@ -56,35 +56,36 @@ module Hallon
       end
     end
 
-    # @return [Boolean] true if the user is loaded
+    # @return [Boolean] true if the user is loaded.
     def loaded?
       Spotify.user_is_loaded(pointer)
     end
 
-    # Retrieve the canonical name of the User.
-    #
-    # @return [String]
+    # @return [String] canonical name of the User.
     def name
       Spotify.user_canonical_name(pointer)
     end
 
-    # Retrieve the dispaly name of the User.
-    #
     # @note Unless {#loaded?} is true, this will return the same thing as {#name}.
-    # @return [String]
+    # @return [String] display name of the User.
     def display_name
       Spotify.user_display_name(pointer)
     end
 
-    # Retrieve the users’ starred playlist.
-    #
     # @note Returns nil unless {User#loaded?}
-    # @return [Playlist, nil]
+    # @return [Playlist, nil] starred playlist of the User.
     def starred
       playlist = Spotify.session_starred_for_user_create!(session.pointer, name)
       Playlist.new(playlist) unless playlist.null?
     end
 
+    # @note Returns nil unless {#loaded?}
+    # @return [PlaylistContainer, nil] published playlists of the User.
+    def published
+      container = Spotify.session_publishedcontainer_for_user_create!(session.pointer, name)
+      PlaylistContainer.new(container) unless container.null?
+    end
+
     # Send tracks to this users’ inbox, with an optional message.
     #
     # @overload post(message, tracks)

data/lib/hallon/version.rb

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

data/spec/hallon/album_browse_spec.rb

@@ -1,6 +1,17 @@
 # coding: utf-8
 describe Hallon::AlbumBrowse do
-  let(:browse) { mock_session { Hallon::AlbumBrowse.new(mock_album) } }
+  describe ".new" do
+    it "should raise an error if the browse request failed" do
+      Spotify.should_receive(:albumbrowse_create).and_return(null_pointer)
+      expect { mock_session { Hallon::AlbumBrowse.new(mock_album) } }.to raise_error(FFI::NullPointerError)
+    end
+  end
+
+  let(:browse) do
+    album = Hallon::Album.new(mock_album)
+    mock_session { Hallon::AlbumBrowse.new(album) }
+  end
+
   subject { browse }
 
   it { should be_loaded }

data/spec/hallon/album_spec.rb

@@ -32,6 +32,9 @@ describe Hallon::Album do
     it "should be nil if there is no image" do
       Spotify.should_receive(:album_cover).and_return(null_pointer)
       album.cover.should be_nil
+
+      Spotify.should_receive(:link_create_from_album_cover).and_return(null_pointer)
+      album.cover(false).should be_nil
     end
 
     it "should be an image if it exists" do

data/spec/hallon/artist_browse_spec.rb

@@ -1,5 +1,12 @@
 # coding: utf-8
 describe Hallon::ArtistBrowse do
+  describe ".new" do
+    it "should raise an error if the browse request failed" do
+      Spotify.should_receive(:artistbrowse_create).and_return(null_pointer)
+      expect { mock_session { Hallon::ArtistBrowse.new(mock_artist) } }.to raise_error(FFI::NullPointerError)
+    end
+  end
+
   let(:browse) do
     artist = Hallon::Artist.new(mock_artist)
     mock_session { Hallon::ArtistBrowse.new(artist) }

data/spec/hallon/artist_spec.rb

@@ -30,19 +30,19 @@ describe Hallon::Artist do
     let(:link) { Hallon::Link.new(mock_image_uri) }
 
     specify "as an image" do
-      Hallon::Session.should_receive(:instance).twice.and_return(session)
-
-      subject.portrait.should eq Hallon::Image.new(mock_image_id)
+      mock_session(2) { artist.portrait.should eq Hallon::Image.new(mock_image_id) }
     end
 
     specify "as a link" do
-      subject.portrait(false).should eq Hallon::Link.new(mock_image_uri)
+      artist.portrait(false).should eq Hallon::Link.new(mock_image_uri)
     end
 
     it "should be nil if an image is not available" do
       Spotify.should_receive(:artist_portrait).and_return(null_pointer)
+      artist.portrait.should be_nil
 
-      subject.portrait.should be_nil
+      Spotify.should_receive(:link_create_from_artist_portrait).and_return(null_pointer)
+      artist.portrait(false).should be_nil
     end
   end
 end

data/spec/hallon/linkable_spec.rb

@@ -22,6 +22,19 @@ describe Hallon::Linkable do
     object.respond_to?(:from_link, true).should be_true
   end
 
+  describe "#to_link" do
+    it "should return nil if link creation failed" do
+      Spotify.should_receive(:link_create_from_user).and_return(null_pointer)
+
+      klass.instance_eval do
+        to_link(:from_user)
+        attr_reader :pointer
+      end
+
+      object.to_link.should be_nil
+    end
+  end
+
   describe "#from_link" do
     it "should call the appropriate Spotify function" do
       Spotify.should_receive(:link_as_search!).and_return(pointer)

data/spec/hallon/playlist_container_spec.rb

@@ -6,14 +6,44 @@ describe Hallon::PlaylistContainer do
 
   it { should be_loaded }
   its(:owner) { should eq Hallon::User.new("burgestrand") }
+  its(:size) { should eq 1 }
 
   describe "#add" do
-    it "should create a new Playlist at the end of the playlist"
+    context "given a string" do
+      it "should create a new Playlist at the end of the playlist" do
+        expect do
+          playlist = container.add("Bogus")
+
+          playlist.name.should eq "Bogus"
+          container.contents[-1].should eq playlist
+        end.to change{ container.size }.by(1)
+      end
+    end
+
+    it "should add the given Playlist to the end of the container" do
+      expect do
+        playlist = container.add Hallon::Playlist.new(mock_playlist)
+        container.contents[-1].should eq Hallon::Playlist.new(mock_playlist)
+      end.to change{ container.size }.by(1)
+    end
+
+    it "should add the given Playlist Link to the end of the container" do
+      expect do
+        playlist = container.add Hallon::Link.new("spotify:user:burgestrand:playlist:07AX9IY9Hqmj1RqltcG0fi")
+        container.contents[-1].should eq Hallon::Playlist.new(mock_playlist)
+      end.to change{ container.size }.by(1)
+    end
+
+    it "should return nil when failing to add the item" do
+      Spotify.should_receive(:playlistcontainer_add_playlist).and_return(null_pointer)
+      playlist = container.add Hallon::Link.new("spotify:user:burgestrand")
+      playlist.should be_nil
+    end
   end
 
   describe "#insert" do
     it "should add the given Playlist to the given index"
-    it "should add the given Folder to the given index", :pending => true
+    it "should add the given Folder to the given index"
   end
 
   describe "#remove" do
@@ -50,12 +80,10 @@ describe Hallon::PlaylistContainer do
     # (8) Playlist #8
     #
     it "should be a collection of folders and playlists"
-  end
 
-  describe "PlaylistContainer Playlists", :pending do
-    subject { container.contents[1] }
-
-    its(:name) { should be "Awesome playlist" }
+    it "should support retrieving playlists" do
+      container.contents[0].should eq Hallon::Playlist.new(mock_playlist)
+    end
   end
 
   describe Hallon::PlaylistContainer::Folder, :pending do

data/spec/hallon/playlist_spec.rb

@@ -31,26 +31,30 @@ describe Hallon::Playlist do
   its(:size) { should eq 4 }
 
   its('tracks.size') { should eq 4 }
-  its('tracks.to_a') { should eq instantiate(Hallon::Playlist::Track, [mock_playlist, 0], [mock_playlist, 1], [mock_playlist, 2], [mock_playlist, 3]) }
+  its('tracks.to_a') { should eq instantiate(Hallon::Playlist::Track, *(0...4).map { |index| [Spotify.playlist_track!(playlist.pointer, index), playlist, index] }) }
+
   describe "tracks#[]" do
+    let(:track) { subject }
     subject { playlist.tracks[0] }
 
     it { should be_seen }
     its(:create_time) { should eq Time.parse("2009-11-04") }
     its(:creator)     { should eq Hallon::User.new(mock_user) }
     its(:message)     { should eq "message this, YO!" }
-  end
 
-  describe "#seen" do
-    it "should set the seen status of the track at the given index" do
-      track = playlist.tracks[0]
-      track.should be_seen
-
-      track = playlist.seen(0, false)
-      track.should_not be_seen
+    describe "#seen=" do
+      it "should raise an error if the track has moved" do
+        track.should be_seen
+        track.playlist.move(1, 0)
+        expect { track.seen = false }.to raise_error(IndexError)
+        track.should be_seen
+      end
 
-      track = playlist.seen(0, true)
-      track.should be_seen
+      it "should update the value of #seen?" do
+        track.should be_seen
+        track.seen = false
+        track.should_not be_seen
+      end
     end
   end
 
@@ -63,6 +67,11 @@ describe Hallon::Playlist do
       Spotify.should_receive(:playlist_subscribers).and_return(mock_empty_subscribers)
       subject.subscribers.should eq []
     end
+
+    it "should return nil when subscriber fetching failed" do
+      Spotify.should_receive(:playlist_subscribers).and_return(null_pointer)
+      playlist.subscribers.should be_nil
+    end
   end
 
   describe "#insert" do

data/spec/hallon/session_spec.rb

@@ -54,8 +54,7 @@ describe Hallon::Session do
   describe "#container" do
     it "should return the sessions’ playlist container" do
       session.login 'burgestrand', 'pass'
-      session.container.should be_a Hallon::PlaylistContainer
-      session.container.owner.should eq session.user
+      session.container.should eq Hallon::PlaylistContainer.new(mock_container)
     end
 
     it "should return nil if not logged in" do

data/spec/hallon/user_spec.rb

@@ -70,5 +70,20 @@ describe Hallon::User do
         mock_session { user.starred.should be_nil }
       end
     end
+
+    describe "#published" do
+      let(:published) { Hallon::PlaylistContainer.new(mock_container) }
+
+      it "should return the playlist container of the user" do
+        Spotify.registry_add("spotify:container:%s" % user.name, mock_container)
+
+        session.login('burgestrand', '')
+        mock_session { user.published.should eq published }
+      end
+
+      it "should return nil if not logged in" do
+        mock_session { user.published.should be_nil }
+      end
+    end
   end
 end

data/spec/mockspotify.rb

@@ -26,13 +26,24 @@ module Spotify
   require 'spotify'
 
   module Mock
+    def self.find_type(*args, &block)
+      Spotify.find_type(*args, &block)
+    end
+
     class PlaylistTrack < FFI::Struct
-      layout :track, :pointer,
+      layout :track, :track,
              :create_time, :int,
-             :creator, :pointer,
+             :creator, :user,
              :message, :pointer,
              :seen, :bool
     end
+
+    class PlaylistContainerItem < FFI::Struct
+      layout :playlist, :playlist,
+             :type, :playlist_type,
+             :folder_name, :pointer,
+             :folder_id, :uint64
+    end
   end
 
   old_verbose, $VERBOSE = $VERBOSE, true
@@ -61,7 +72,7 @@ module Spotify
   attach_function :mock_toplistbrowse, :mocksp_toplistbrowse_create, [:error, :int, :int, :array, :int, :array, :int, :array], :toplistbrowse
 
   attach_mock_function :mock_playlist, :mocksp_playlist_create, [:string, :bool, :user, :bool, :string, :image_id, :bool, :uint, Spotify::Subscribers, :bool, :playlist_offline_status, :int, :int, :array], :playlist
-  attach_mock_function :mock_playlistcontainer, :mocksp_playlistcontainer_create, [:user, :bool], :playlistcontainer
+  attach_mock_function :mock_playlistcontainer, :mocksp_playlistcontainer_create, [:user, :bool, :int, :array, PlaylistContainerCallbacks, :userdata], :playlistcontainer
   attach_function :mock_search, :mocksp_search_create, [:error, :string, :string, :int, :int, :array, :int, :int, :array, :int, :int, :array, :search_complete_cb, :pointer], :search
   attach_function :mock_subscribers, :mocksp_subscribers, [:int, :array], Spotify::Subscribers
 

data/spec/support/common_objects.rb

@@ -146,14 +146,23 @@ RSpec::Core::ExampleGroup.instance_eval do
   end
 
   let(:mock_container) do
-    owner = Spotify.registry_find("spotify:user:burgestrand")
-    Spotify.mock_playlistcontainer(owner, true)
+    num_items = 1
+    items_ptr = FFI::MemoryPointer.new(Spotify::Mock::PlaylistTrack, num_items)
+    items = num_items.times.map do |i|
+      Spotify::Mock::PlaylistContainerItem.new(items_ptr + Spotify::Mock::PlaylistContainerItem.size * i)
+    end
+
+    items[0][:playlist] = mock_playlist
+    items[0][:type]     = :playlist
+
+    Spotify.mock_playlistcontainer(mock_user, true, num_items, items_ptr, nil, nil)
   end
 end
 
 RSpec.configure do |config|
   config.before do
     Spotify.registry_add mock_image_uri, mock_image
+    Spotify.registry_add 'spotify:container:burgestrand', mock_container
     Spotify.registry_add 'spotify:albumbrowse:1xvnWMz2PNFf7mXOSRuLws', mock_albumbrowse
     Spotify.registry_add 'spotify:artistbrowse:3bftcFwl4vqRNNORRsqm1G', mock_artistbrowse
     Spotify.registry_add 'spotify:artist:3bftcFwl4vqRNNORRsqm1G', mock_artist

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hallon
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-20 00:00:00.000000000 Z
+date: 2011-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: spotify
-  requirement: &70146970531060 !ruby/object:Gem::Requirement
+  requirement: &70199932063240 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 10.1.0
   type: :runtime
   prerelease: false
-  version_requirements: *70146970531060
+  version_requirements: *70199932063240
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &70146970529600 !ruby/object:Gem::Requirement
+  requirement: &70199932060440 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: '1.0'
   type: :development
   prerelease: false
-  version_requirements: *70146970529600
+  version_requirements: *70199932060440
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70146970527480 !ruby/object:Gem::Requirement
+  requirement: &70199932058360 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: '0.8'
   type: :development
   prerelease: false
-  version_requirements: *70146970527480
+  version_requirements: *70199932058360
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70146970524260 !ruby/object:Gem::Requirement
+  requirement: &70199932057240 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +54,10 @@ dependencies:
         version: '2'
   type: :development
   prerelease: false
-  version_requirements: *70146970524260
+  version_requirements: *70199932057240
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: &70146970523640 !ruby/object:Gem::Requirement
+  requirement: &70199932056420 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70146970523640
+  version_requirements: *70199932056420
 - !ruby/object:Gem::Dependency
   name: rdiscount
-  requirement: &70146970522520 !ruby/object:Gem::Requirement
+  requirement: &70199932055320 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,7 +76,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70146970522520
+  version_requirements: *70199932055320
 description: 
 email: kim@burgestrand.se
 executables: []