ejaydj 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 05049a5b86d65ec05cd7f5a1ca0d3aebec538b94
+  data.tar.gz: 5470db550bcfbcea11dfc336b86539b3f9bddb93
+SHA512:
+  metadata.gz: 9a0601efca20f9fade644fa5c1f186314b06c01430507ca5eb5974c4a394d01638b4d1bd5a21ccffff1047e24ee348791174868d495920ed93cdf2ffe7427576
+  data.tar.gz: 81d7b1b13d42f01f9edb07a2182fd77e918daa0cefa8a5f9b5f0aba8771a7aeb9741502862399a7cde13ebd6a0d518d0acc98aad216a6f8028223a203394205a

data/.editorconfig

@@ -0,0 +1,36 @@
+# EditorConfig is awesome: http://EditorConfig.org
+# top-most EditorConfig file
+root = true
+
+# Unix-style newlines with a newline ending every file
+[*]
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 2
+
+# 4 space indentation
+[*.py]
+indent_style = space
+indent_size = 4
+
+[*.js]
+indent_style = space
+indent_size = 4
+
+[*.rb]
+indent_style = space
+indent_size = 2
+
+[*.haml]
+indent_style = space
+indent_size = 2
+
+[*.scss]
+indent_style = space
+indent_size = 4
+
+# Indentation override for all JS under lib directory
+[lib/**.js]
+indent_style = space
+indent_size = 2

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+cache: bundler
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.2

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ejaydj.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Ejay Canaria
+
+MIT License
+
+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,81 @@
+# Ejaydj
+
+[![Build Status](https://travis-ci.org/ejaypcanaria/ejaydj.svg)](https://travis-ci.org/ejaypcanaria/ejaydj)
+
+A bot that tweets songs from your music playlists on Spotify. Implemented using Twitter and Spotify API, let your music be heard! This is where music really never stops.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ejaydj'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ejaydj
+
+## Configuration
+
+### Prerequisites
+1. [Twitter consumer and access token](https://developer.spotify.com/my-applications/#!/)
+2. [Spotify client id and secret](https://apps.twitter.com/)
+
+### Set the Spotify and Twitter credentials in your new TwitterBot DJ then add your playlists
+
+```ruby
+dj = Ejaydj::Djs::TwitterBot.new do |config|
+  config.music_user_id               = 'spotify_user_id'
+  config.music_client_id             = 'spotify_client_id'
+  config.music_client_secret         = 'spotify_client_secret'
+
+  config.twitter_consumer_key        = 'twitter_consumer_key'
+  config.twitter_consumer_secret     = 'twitter_consumer_secret'
+  config.twitter_access_token        = 'twitter_access_token'
+  config.twitter_access_token_secret = 'twitter_access_token_secret'
+
+
+  config.morning_playlists           = ["Morning Playlist 1", "Morning Playlist 2"]
+  config.noon_playlists              = ["Noon Playlist 1", "Noon Playlist 2"]
+  config.night_playlists             = ["Night Playlist 1", "Night Playlist 2"]
+  config.late_night_playlists        = ["Late Night Playlist 1", "Late Night Playlist 2"]
+end
+```
+
+**NOTE: You need to provide at least 1 playlist for each time spot**
+
+## Tweeting Your Music
+Given a `dj` object from the above configuration, tweeting your music is as simple as:
+```ruby
+  dj.tweet_me_a_song
+```
+
+The tweet format will look like:
+`NP: {song} by {artist} from {playlist} playlist: {playlist_url}`
+Each songs is based on the provided time (default is current time). It will automatically lookup for tracks in the scheduled playlists.
+
+## Playlists Schedule
+Playlists are group into four time spots as you have seen in the configuration earlier. These time spots are:
+
+1. Morning      - 6:00AM   - 11:59PM
+2. Noon         - 12:00PM  - 5:59PM
+3. Night        - 6:00PM   - 10:59PM
+4. Late Night   - 11:PM    - 5:59AM
+
+By default, the current time used is `Time.now`. You can override it by passing a `time` parameter on the `tweet_me_a_song` method:
+
+```ruby
+  dj.tweet_me_a_song(time: Time.new(2014, 11, 20, 14, 0, 0))
+```
+
+
+## Contributing
+
+1. Fork it ( https://github.com/ejaypcanaria/ejaydj/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,5 @@
+require "bundler/gem_tasks"
+
+task default: :spec do
+  system 'rspec --color --format documentation'
+end

data/ejaydj.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ejaydj/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ejaydj"
+  spec.version       = Ejaydj::VERSION
+  spec.authors       = ["Ejay Canaria"]
+  spec.email         = ["ejaypcanaria@gmail.com"]
+  spec.summary       = %q{A bot that tweets a song based on your spotify playlists}
+  spec.description   = %q{A bot that tweets a song based on your spotify playlists}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "rest-client", "~> 1.7"
+  spec.add_runtime_dependency "json"
+  spec.add_runtime_dependency "twitter"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "pry"
+
+end

data/lib/ejaydj.rb

@@ -0,0 +1,5 @@
+require 'ejaydj/dj'
+require 'ejaydj/playlist'
+require 'ejaydj/track'
+
+require 'ejaydj/djs/twitter_bot'

data/lib/ejaydj/dj.rb

@@ -0,0 +1,79 @@
+require 'ejaydj/services/playlist_service'
+require 'ejaydj/spotify/client'
+
+module Ejaydj
+  class Dj
+    PLAYLIST_SCHEDULE = {
+      600..1159   => :morning_playlists,      # 6AM  - 12PM
+      1200..1759  => :noon_playlists,         # 12PM - 5:59PM
+      1800..2259  => :night_playlists,        # 6PM  - 10:59PM
+      2300..2359  => :late_night_playlists,   # 11PM - 11:59AM
+      0..559      => :late_night_playlists    # 12AM - 5:59AM
+    }
+
+    attr_accessor :music_client_id,
+                  :music_client_secret,
+                  :music_user_id,
+                  :music_client,
+                  :morning_playlists,
+                  :noon_playlists,
+                  :night_playlists,
+                  :late_night_playlists
+
+
+    def initialize(attributes={})
+      instantiate_variables_from attributes
+      yield self if block_given?
+    end
+
+    def play_me_a_song(time: Time.now)
+      current_playlist(time).next_track
+    end
+
+    def playlists
+      @playlists ||= all_playlists
+    end
+
+    def reload!
+      @playlists = all_playlists
+      @playlists.each {|playlist| playlist.reload!}
+    end
+
+    private
+
+    def current_playlist(time)
+      playlist_name = scheduled_playlist(time.strftime('%k%M').to_i)
+      playlist = playlists.select do |playlist|
+        playlist.name == playlist_name
+      end.first
+    end
+
+    def scheduled_playlist(time)
+      scheduled_playlists = PLAYLIST_SCHEDULE.select do |schedule, value|
+        schedule.cover? time
+      end.values.first
+
+      send(scheduled_playlists).sample
+    end
+
+    def all_playlists
+      playlist_service.all
+    end
+
+    def playlist_service
+      @playlist_service ||= Services::PlaylistService.new(
+                                music_client: music_client,
+                                user_id: music_user_id)
+    end
+
+    def music_client
+      @music_client ||= Spotify::Client.new(
+                          client_id: music_client_id,
+                          client_secret: music_client_secret)
+    end
+
+    def instantiate_variables_from(attributes)
+      attributes.each {|key, val| instance_variable_set(:"@#{key}", val) }
+    end
+  end
+end

data/lib/ejaydj/djs/twitter_bot.rb

@@ -0,0 +1,36 @@
+require 'twitter'
+
+module Ejaydj
+  module Djs
+    class TwitterBot < Ejaydj::Dj
+      attr_accessor :twitter_consumer_key,
+                    :twitter_consumer_secret,
+                    :twitter_access_token,
+                    :twitter_access_token_secret,
+                    :twitter_client
+
+      def initialize(attributes={}, &block)
+        super(attributes, &block)
+      end
+
+      def tweet_me_a_song(time: Time.now)
+        song = play_me_a_song(time: time)
+        tweet = "NP: #{song.name} by #{song.artist} from #{song.playlist.name} playlist: #{song.playlist.url}"
+        twitter_client.update(tweet)
+
+        {message: tweet, song: song}
+      end
+
+      private
+
+      def twitter_client
+        @twitter_client ||= Twitter::REST::Client.new do |config|
+          config.consumer_key        = @twitter_consumer_key
+          config.consumer_secret     = @twitter_consumer_secret
+          config.access_token        = @twitter_access_token
+          config.access_token_secret = @twitter_access_token_secret
+        end
+      end
+    end
+  end
+end

data/lib/ejaydj/playlist.rb

@@ -0,0 +1,49 @@
+require 'ejaydj/services/track_service'
+
+module Ejaydj
+  class Playlist
+    attr_reader :id,
+                :user_id,
+                :name,
+                :url,
+                :number_of_tracks
+
+    def initialize(attributes={})
+      @id               = attributes[:id]
+      @user_id          = attributes[:user_id]
+      @name             = attributes[:name]
+      @url              = attributes[:url]
+      @number_of_tracks = attributes[:number_of_tracks]
+
+      @music_client     = attributes[:music_client]
+    end
+
+    def next_track
+      reload! if tracks.empty?
+      track = tracks.pop
+      track.playlist = self
+      track
+    end
+
+    def tracks
+      @tracks ||= all_tracks
+    end
+
+    def reload!
+      @tracks = all_tracks
+    end
+
+    private
+
+    def all_tracks
+      track_service.all.shuffle
+    end
+
+    def track_service
+      @track_service ||= Services::TrackService.new(
+                                          music_client: @music_client,
+                                          user_id: @user_id,
+                                          playlist_id: @id)
+    end
+  end
+end

data/lib/ejaydj/services/playlist_service.rb

@@ -0,0 +1,27 @@
+module Ejaydj
+  module Services
+    class PlaylistService
+
+      def initialize(music_client: nil, user_id: nil)
+        @music_client = music_client
+        @user_id      = user_id
+      end
+
+      def all
+        response_items = @music_client.user_playlists(user_id: @user_id)
+
+        response_items.map do |playlist|
+          Playlist.new(
+            id:                 playlist["id"],
+            user_id:            playlist["owner"]["id"],
+            name:               playlist["name"],
+            url:                playlist["external_urls"]["spotify"],
+            number_of_tracks:   playlist["tracks"]["total"],
+
+            music_client:       @music_client)
+        end
+      end
+
+    end
+  end
+end

data/lib/ejaydj/services/track_service.rb

@@ -0,0 +1,25 @@
+module Ejaydj
+  module Services
+    class TrackService
+      def initialize(music_client: nil, user_id: nil, playlist_id: nil)
+        @music_client = music_client
+        @user_id      = user_id
+        @playlist_id  = playlist_id
+      end
+
+      def all
+        response_items = @music_client.playlist_tracks(user_id: @user_id, playlist_id: @playlist_id)
+
+        response_items.map do |track|
+          Track.new(
+            id:            track["track"]["id"],
+            name:          track["track"]["name"],
+            album:         track["track"]["album"]["name"],
+            artist:        track["track"]["artists"][0]["name"],
+            duration_ms:   track["track"]["duration_ms"]
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ejaydj/spotify/client.rb

@@ -0,0 +1,68 @@
+require 'rest_client'
+require 'base64'
+require 'json'
+
+require 'pry'
+
+module Ejaydj
+  module Spotify
+    class Client
+
+      API_URL 					= 'https://api.spotify.com'
+      ACCOUNT_API_URL		= 'https://accounts.spotify.com'
+
+      def initialize(config={})
+        @rest_client   = config[:rest_client] || RestClient
+        @client_id 		 = config[:client_id]
+        @client_secret = config[:client_secret]
+      end
+
+      def user_playlists(user_id: nil)
+        url = "#{API_URL}/v1/users/#{user_id}/playlists?limit=50"
+        response = get_request(url)
+        fetch_items(response)
+      end
+
+      def playlist_tracks(user_id: nil, playlist_id: nil)
+        url = "#{API_URL}/v1/users/#{user_id}/playlists/#{playlist_id}/tracks"
+        response = get_request(url)
+        fetch_items(response)
+      end
+
+      private
+
+      def fetch_items(response)
+        response_items = response["items"]
+        next_url = response["next"]
+
+        while next_url do
+          response = get_request(next_url)
+          response_items += response["items"]
+
+          next_url = response["next"]
+        end
+
+        response_items
+      end
+
+      def get_request(url)
+        JSON.parse(@rest_client.get(url, headers))
+      end
+
+      def headers
+        {"Authorization" => "Bearer #{get_access_token}"}
+      end
+
+      def get_access_token
+        encoded_client_id_secret = Base64.strict_encode64("#{@client_id}:#{@client_secret}")
+        payload = {grant_type: 'client_credentials'}
+        headers = {"Authorization" => "Basic #{encoded_client_id_secret}"}
+
+        response = @rest_client.post("#{ACCOUNT_API_URL}/api/token", payload, headers)
+
+        return JSON.parse(response)["access_token"]
+      end
+
+    end
+  end
+end

data/lib/ejaydj/track.rb

@@ -0,0 +1,19 @@
+module Ejaydj
+  class Track
+    attr_reader   :name,
+                  :album,
+                  :artist,
+                  :duration_ms
+
+    attr_accessor :playlist
+
+    def initialize(attributes={})
+      @id            = attributes[:id]
+      @name          = attributes[:name]
+      @album         = attributes[:album]
+      @artist        = attributes[:artist]
+      @playlist      = attributes[:playlist]
+      @duration_ms   = attributes[:duration_ms]
+    end
+  end
+end

data/lib/ejaydj/version.rb

@@ -0,0 +1,3 @@
+module Ejaydj
+  VERSION = "0.0.1"
+end

data/spec/dj_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+RSpec.describe Ejaydj::Dj do
+
+  let(:dj) do
+    Ejaydj::Dj.new do |config|
+      config.music_user_id        = 'user_1'
+      config.music_client_id      = 'client_1'
+      config.music_client_secret  = 'client_secret_1'
+      config.music_client         = music_client
+      config.morning_playlists    = ["Morning Playlist"]
+      config.noon_playlists       = ["Noon Playlist"]
+      config.night_playlists      = ["Night Playlist"]
+      config.late_night_playlists = ["Late Night Playlist"]
+    end
+  end
+
+  let(:playlist_items) do
+    [
+      {"name" => "Morning Playlist", "owner" => {"id" => 1}, "external_urls" => {"spotify" => "/playlist_morning"}, "tracks" => {"total" => 10}},
+      {"name" => "Noon Playlist", "owner" => {"id" => 2}, "external_urls" => {"spotify" => "/playlist_noon"}, "tracks" => {"total" => 10}},
+      {"name" => "Night Playlist", "owner" => {"id" => 3}, "external_urls" => {"spotify" => "/playlist_night"}, "tracks" => {"total" => 10}},
+      {"name" => "Late Night Playlist", "owner" => {"id" => 4}, "external_urls" => {"spotify" => "/playlist_late_night"}, "tracks" => {"total" => 10}}
+    ]
+  end
+
+  let(:track_items) do
+    [
+      {"track" => { "id"            => 1,
+                    "name"          => "Track 1",
+                    "album"         => {"name" => "Album 1"},
+                    "artists"       => [{"name" => "Artist 1"}],
+                    "playlist_id"   => 1
+                   }}
+    ]
+  end
+
+  let(:music_client) { double('MusicClient') }
+
+  before do
+    allow(music_client).to receive(:user_playlists).and_return(playlist_items)
+    allow(music_client).to receive(:playlist_tracks).and_return(track_items)
+  end
+
+  describe '#play_me_a_song' do
+    context "when played in the morning" do
+      it "plays the song from the morning playlists" do
+        song = dj.play_me_a_song(time: Time.new(2014, 11, 20, 6, 30, 0))
+        expect(dj.morning_playlists).to include(song.playlist.name)
+      end
+    end
+
+    context "when played in the noon" do
+      it "plays the song from the noon playlists" do
+        song = dj.play_me_a_song(time: Time.new(2014, 11, 20, 17, 45, 0))
+        expect(dj.noon_playlists).to include(song.playlist.name)
+      end
+    end
+
+    context "when played in night" do
+      it "plays the song from the night playlists" do
+        song = dj.play_me_a_song(time: Time.new(2014, 11, 20, 18, 0, 0))
+        expect(dj.night_playlists).to include(song.playlist.name)
+      end
+    end
+
+    context "when played in late night" do
+      it "plays the song from the late night playlists" do
+        song = dj.play_me_a_song(time: Time.new(2014, 11, 20, 23, 15, 0))
+        expect(dj.late_night_playlists).to include(song.playlist.name)
+      end
+    end
+  end
+
+  describe '#playlists' do
+    it "returns all the dj's playlists" do
+      expect(dj.playlists.count).to eq(playlist_items.count)
+    end
+  end
+
+  describe '#reload!' do
+    it "reloads the playlist" do
+      dj.playlists
+      playlist_items << {"name" => "Morning Playlist 2", "owner" => {"id" => 5}, "external_urls" => {"spotify" => "/playlist_morning_2"}, "tracks" => {"total" => 10}}
+      dj.reload!
+
+      expect(dj.playlists.count).to eq(playlist_items.count)
+    end
+
+    it "reloads the playlist's tracks" do
+      dj.playlists.first.tracks
+      track_items << { "track" => {"id" => 2,
+                                   "name"          => "Track 2",
+                                   "album"         => {"name" => "Album 2"},
+                                   "artists"       => [{"name" => "Artist 2"}],
+                                   "playlist_id"   => 2
+                     }}
+      dj.reload!
+      expect(dj.playlists.first.tracks.count).to eq(track_items.count)
+    end
+  end
+
+end

data/spec/djs/twitter_bot_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+RSpec.describe Ejaydj::Djs::TwitterBot do
+
+  let(:music_client)    { double('MusicClient') }
+  let(:twitter_client)  { double('TwitterClient', update: true)}
+
+  let(:twitter_bot_dj) do
+    Ejaydj::Djs::TwitterBot.new do |config|
+      config.music_user_id        = 'user_1'
+      config.music_client_id      = 'client_1'
+      config.music_client_secret  = 'client_secret_1'
+      config.music_client         = music_client
+
+      config.twitter_consumer_key        = 'consumer_key'
+      config.twitter_consumer_secret     = 'consumer_secret'
+      config.twitter_access_token        = 'access_token'
+      config.twitter_access_token_secret = 'token_secret'
+      config.twitter_client              = twitter_client
+
+      config.morning_playlists    = ["Morning Playlist"]
+      config.noon_playlists       = ["Noon Playlist"]
+      config.night_playlists      = ["Night Playlist"]
+      config.late_night_playlists = ["Late Night Playlist"]
+    end
+  end
+
+  let(:playlist_items) do
+    [
+      {"name" => "Morning Playlist", "owner" => {"id" => 1}, "external_urls" => {"spotify" => "/playlist_morning"}, "tracks" => {"total" => 10}}
+    ]
+  end
+
+  let(:track_items) do
+    [
+      {"track" => { "id"            => 1,
+                    "name"          => "Track 1",
+                    "album"         => {"name" => "Album 1"},
+                    "artists"       => [{"name" => "Artist 1"}]
+                   }}
+    ]
+  end
+
+  before do
+    allow(music_client).to receive(:user_playlists).and_return(playlist_items)
+    allow(music_client).to receive(:playlist_tracks).and_return(track_items)
+  end
+
+  describe '#tweet_me_a_song' do
+    it "tweets a song" do
+      tweet = twitter_bot_dj.tweet_me_a_song(time: Time.new(2014, 11, 20, 7, 0, 0))
+      song = tweet[:song]
+
+      expect(tweet[:message]).to eq("NP: #{song.name} by #{song.artist} from #{song.playlist.name} playlist: #{song.playlist.url}")
+    end
+  end
+
+end

data/spec/playlist_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+RSpec.describe Ejaydj::Playlist do
+
+  let(:music_client) { double('MusicClient') }
+  let(:playlist) do
+    Ejaydj::Playlist.new(
+      name: 'Playlist 1',
+      music_client: music_client)
+  end
+
+  let(:track_items) do
+    [
+      {"track" => { "id"            => 1,
+                    "name"          => "Track 1",
+                    "album"         => {"name" => "Album 1"},
+                    "artists"       => [{"name" => "Artist 1"}],
+                    "playlist_id"   => 1
+                   }}
+    ]
+  end
+
+  before do
+    allow(music_client).to receive(:playlist_tracks).and_return(track_items)
+  end
+
+  describe '#next_track' do
+    it "returns the next track in the playlist" do
+      track = playlist.next_track
+      expect(track.name).to eq(track_items.first["track"]["name"])
+    end
+
+    it "removes the returned track from the playlist" do
+      track = playlist.next_track
+      expect(playlist.tracks).to_not include(track)
+    end
+
+    context "when there's no track left" do
+      it "reloads the playlist and return a track" do
+        playlist.next_track
+
+        new_track = playlist.next_track
+        expect(new_track).to_not be_nil
+      end
+    end
+  end
+
+  describe '#tracks' do
+    it "returns all the playlist's tracks" do
+      expect(playlist.tracks.count).to eq(track_items.count)
+    end
+  end
+
+  describe '#reload!' do
+    it "reloads all the tracks" do
+      playlist.tracks
+      track_items << { "track" => {"id" => 2,
+                                   "name"          => "Track 2",
+                                   "album"         => {"name" => "Album 2"},
+                                   "artists"       => [{"name" => "Artist 2"}],
+                                   "playlist_id"   => 2
+                     }}
+      playlist.reload!
+      expect(playlist.tracks.count).to eq(track_items.count)
+    end
+  end
+
+end

data/spec/services/playlist_service_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'pry'
+
+RSpec.describe Ejaydj::Services::PlaylistService do
+
+  let(:music_client) { double('MusicClient') }
+  let(:playlist_service) do
+    Ejaydj::Services::PlaylistService.new(music_client: music_client, user_id: 1)
+  end
+
+  describe '#all' do
+    let(:response) do
+      [{"id" => 1, "owner" => {"id" => 1}, "name" => 'Playlist 1', "external_urls" => '/playlist1', "tracks" => {"total" => 10}},
+       {"id" => 2, "owner" => {"id" => 1}, "name" => 'Playlist 2', "external_urls" => '/playlist2', "tracks" => {"total" => 20}}]
+    end
+
+    before do
+      allow(music_client).to receive(:user_playlists).and_return(response)
+    end
+
+    it "returns a list of Playlists" do
+      playlists = playlist_service.all
+      expect(playlists.first.class).to eq Ejaydj::Playlist
+    end
+
+    it "returns all playlists of the user" do
+      playlists = playlist_service.all
+      expect(playlists.count).to eq response.count
+    end
+
+  end
+end

data/spec/services/track_service_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+RSpec.describe Ejaydj::Services::TrackService do
+
+  let(:music_client) { double('MusicClient') }
+  let(:track_service) do
+    Ejaydj::Services::TrackService.new(music_client: music_client, user_id: 1, playlist_id: 1)
+  end
+
+  describe '#all' do
+    let(:response) do
+      [{"track" => {"id"            => 1,
+                    "name"          => "Track 1",
+                    "album"         => {"name" => "Album 1"},
+                    "artists"       => [{"name" => "Artist 1"}],
+                    "playlist_id"   => 1
+                   }},
+
+       {"track" => {"id"            => 2,
+                    "name"          => "Track 2",
+                    "album"         => {"name" => "Album 2"},
+                    "artists"       => [{"name" => "Artist 2"}],
+                    "playlist_id"   => 2
+                   }}
+      ]
+    end
+
+    before do
+      allow(music_client).to receive(:playlist_tracks).and_return(response)
+    end
+
+    it "returns a list of Tracks" do
+      tracks = track_service.all
+      expect(tracks.first.class).to eq Ejaydj::Track
+    end
+
+    it "returns all the tracks of the playlist" do
+      tracks = track_service.all
+      expect(tracks.count).to eq response.count
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'ejaydj'

data/spec/spotify/client_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+RSpec.describe Ejaydj::Spotify::Client do
+
+  let(:rest_client) { double('RestClient') }
+  let(:spotify_client) do
+    Ejaydj::Spotify::Client.new(rest_client:   rest_client,
+                                client_id:     'client_1',
+                                client_secret: 'client_secret_1')
+  end
+
+  before do
+    allow(rest_client).to receive(:get).and_return(response)
+    allow(rest_client).to receive(:post).with(
+      "#{Ejaydj::Spotify::Client::ACCOUNT_API_URL}/api/token", anything(), anything())
+        .and_return('{"access_token": "token_1"}')
+  end
+
+  describe '#user_playlists' do
+    let(:response) do
+      '{ "items": [
+          {"name": "Playlist 1"},
+          {"name": "Playlist 2"}
+        ]
+      }'
+    end
+
+    it "returns the given user playlists as an array of JSON" do
+      response_items = spotify_client.user_playlists(user_id: 1)
+      expect(response_items.first.class).to eq(Hash)
+    end
+  end
+
+  describe '#playlist_tracks' do
+    let(:response) do
+      '{ "items": [
+          {"name": "Track 1"},
+          {"name": "Track 2"}
+        ]
+      }'
+    end
+
+    it "returns the the given playlist's tracks as an array of JSON" do
+      response_items = spotify_client.playlist_tracks(user_id: 1, playlist_id: 1)
+      expect(response_items.first.class).to eq(Hash)
+    end
+  end
+
+end

metadata

@@ -0,0 +1,173 @@
+--- !ruby/object:Gem::Specification
+name: ejaydj
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ejay Canaria
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: twitter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A bot that tweets a song based on your spotify playlists
+email:
+- ejaypcanaria@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".editorconfig"
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ejaydj.gemspec
+- lib/ejaydj.rb
+- lib/ejaydj/dj.rb
+- lib/ejaydj/djs/twitter_bot.rb
+- lib/ejaydj/playlist.rb
+- lib/ejaydj/services/playlist_service.rb
+- lib/ejaydj/services/track_service.rb
+- lib/ejaydj/spotify/client.rb
+- lib/ejaydj/track.rb
+- lib/ejaydj/version.rb
+- spec/dj_spec.rb
+- spec/djs/twitter_bot_spec.rb
+- spec/playlist_spec.rb
+- spec/services/playlist_service_spec.rb
+- spec/services/track_service_spec.rb
+- spec/spec_helper.rb
+- spec/spotify/client_spec.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A bot that tweets a song based on your spotify playlists
+test_files:
+- spec/dj_spec.rb
+- spec/djs/twitter_bot_spec.rb
+- spec/playlist_spec.rb
+- spec/services/playlist_service_spec.rb
+- spec/services/track_service_spec.rb
+- spec/spec_helper.rb
+- spec/spotify/client_spec.rb