soundly 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a6d8bf9107134324f78f29c81fc570d03e1a7d1d
-  data.tar.gz: 134e8433ca1fed1b86207e8bbd0e9405af65f823
+  metadata.gz: 982a1a80bc9696fc2a87fde99ad336371b01b04a
+  data.tar.gz: 630fbde11a7f552b0ea8b5338bf70ca1abb2cf88
 SHA512:
-  metadata.gz: 0959dbdccc117c87b86d98dc6a2fafe211398211f9b1bf9bb8e2d3a3f6e938e55578f5b886d6800340e2f232f2fdb6673497df6b13b4d67a2a383c0fee649456
-  data.tar.gz: 585d2117e6f35015e505074df924845c37203349315460fffd48d0fc49ed71ccf96ddecfdacb74f38daabc7d31fd142dd578830f8741fb3a01132d9f0be1f30b
+  metadata.gz: f6b97db82e320dd6c264765a491cc3ea490ae4ebaf7171f50329523923af41507ff1279900df2528a801e72df92376a138c55b08462572e8ee82fee97c3f0095
+  data.tar.gz: a0ed2fb4a3b79a8fa58575c525bfe5fa3188cb8b5e8dd0f7fe22d1c7f0afbaa7d33f0c1429e91d638a3e025f75856854388d0e73023596451d646ec1aa96f147

data/.gitignore

@@ -1,3 +1,4 @@
+.env
 /.bundle/
 /.yardoc
 /Gemfile.lock

data/Rainbow.md

@@ -0,0 +1,224 @@
+# Rainbow
+
+[![Gem Version](https://badge.fury.io/rb/rainbow.svg)](https://rubygems.org/gems/rainbow)
+[![Build Status](https://travis-ci.org/sickill/rainbow.svg?branch=master)](https://travis-ci.org/sickill/rainbow)
+[![Build status](https://ci.appveyor.com/api/projects/status/vq4acb2c38642s5q?svg=true)](https://ci.appveyor.com/project/sickill/rainbow)
+[![Code Climate](https://codeclimate.com/github/sickill/rainbow.svg)](https://codeclimate.com/github/sickill/rainbow)
+[![Coverage Status](https://coveralls.io/repos/sickill/rainbow/badge.svg)](https://coveralls.io/r/sickill/rainbow)
+
+Rainbow is a ruby gem for colorizing printed text on ANSI terminals.
+
+It provides a string presenter object, which adds several methods to your
+strings for wrapping them in [ANSI escape
+codes](http://en.wikipedia.org/wiki/ANSI_escape_code). These codes when printed
+in a terminal change text attributes like text color, background color,
+intensity etc.
+
+## Usage
+
+To make your string colored wrap it with `Rainbow()` presenter and call
+`.color(<color name>)` on it.
+
+### Example
+
+```ruby
+require 'rainbow'
+
+puts Rainbow("this is red").red + " and " + Rainbow("this on yellow bg").bg(:yellow) + " and " + Rainbow("even bright underlined!").underline.bright
+
+# => "\e[31mthis is red\e[0m and \e[43mthis on yellow bg\e[0m and \e[4m\e[1meven bright underlined!\e[0m"
+```
+
+Or, [watch this video example](https://asciinema.org/a/J928KpHoUQ0sl54ulOSOLE71E?rows=20&speed=2.5)
+
+### Rainbow presenter API
+
+Rainbow presenter adds the following methods to presented string:
+
+* `color(c)` (with `foreground`, and `fg` aliases)
+* `background(c)` (with `bg` alias)
+* `bright`
+* `underline`
+* `blink`
+* `inverse`
+* `hide`
+* `faint` (not well supported by terminal emulators)
+* `italic` (not well supported by terminal emulators)
+
+Text color can also be changed by calling a method named by a color:
+
+* `black`
+* `red`
+* `green`
+* `yellow`
+* `blue`
+* `magenta`
+* `cyan`
+* `white`
+* `aqua`
+* `silver`
+* `aliceblue`
+* `indianred`
+
+All of the methods return `self` (the presenter object) so you can chain method
+calls:
+
+```ruby
+Rainbow("hola!").blue.bright.underline
+```
+
+### Refinement
+
+If you want to use the Refinements version, you can:
+
+```ruby
+require 'rainbow/refinement'
+using Rainbow
+puts "Hi!".green
+```
+
+Here's an IRB session example:
+
+```
+>> 'Hello, World!'.blue.bright.underline
+NoMethodError: undefined method `blue' for "Hello, World!":String
+    (ripl):1:in `<main>'
+>> using Rainbow
+=> main
+>> 'Hello, World!'.blue.bright.underline
+=> "\e[34m\e[1m\e[4mHello, World!\e[0m"
+```
+
+### Color specification
+
+Both `color` and `background` accept color specified in any
+of the following ways:
+
+* ANSI color number (where 0 is black, 1 is red, 2 is green and so on):
+  `Rainbow("hello").color(1)`
+
+* [ANSI color](https://en.wikipedia.org/wiki/ANSI_escape_code#Colors) name or [X11 color](https://en.wikipedia.org/wiki/X11_color_names) name as a symbol:
+  `Rainbow("hello").color(:yellow)`.
+  This can be simplified to `Rainbow("hello").yellow`  
+  
+  See [Color list](#user-content-color-list) for all available color names.  
+  Note that ANSI colors can be changed in accordance with terminal setting.  
+  But X11 color is just a syntax sugar for RGB triplet. So you always see what you specified.
+
+* RGB triplet as separate values in the range 0-255:
+  `Rainbow("hello").color(115, 23, 98)`
+
+* RGB triplet as a hex string:
+  `Rainbow("hello").color("FFC482")` or `Rainbow("hello").color("#FFC482")`
+
+When you specify a color with a RGB triplet rainbow finds the nearest match
+from 256 colors palette. Note that it requires a 256-colors capable terminal to
+display correctly.
+
+#### Example: Choose a random color
+
+You can pick a random color with Rainbow, it's a one-liner:
+
+```ruby
+colors = Range.new(0,7).to_a
+"whoop dee doop".chars.map { |char| Rainbow(char).color(colors.sample) }.join
+# => "\e[36mw\e[0m\e[37mh\e[0m\e[34mo\e[0m\e[34mo\e[0m\e[37mp\e[0m\e[34m \e[0m\e[36md\e[0m\e[33me\e[0m\e[34me\e[0m\e[37m \e[0m\e[32md\e[0m\e[35mo\e[0m\e[33mo\e[0m\e[36mp\e[0m"
+
+colors = [:aliceblue, :antiquewhite, :aqua, :aquamarine, :azure, :beige, :bisque, :blanchedalmond, :blueviolet]
+"whoop dee doop".chars.map { |char| Rainbow(char).color(colors.sample) }.join
+# => "\e[38;5;135mw\e[0m\e[38;5;230mh\e[0m\e[38;5;231mo\e[0m\e[38;5;135mo\e[0m\e[38;5;231mp\e[0m\e[38;5;231m \e[0m\e[38;5;122md\e[0m\e[38;5;231me\e[0m\e[38;5;231me\e[0m\e[38;5;230m \e[0m\e[38;5;122md\e[0m\e[38;5;51mo\e[0m\e[38;5;51mo\e[0m\e[38;5;51mp\e[0m"
+```
+
+### Configuration
+
+Rainbow can be enabled/disabled globally by setting:
+
+```ruby
+Rainbow.enabled = true/false
+```
+
+When disabled all the methods return an unmodified string
+(`Rainbow("hello").red == "hello"`).
+
+It's enabled by default, unless STDOUT/STDERR is not a TTY or a terminal is
+dumb.
+
+### Advanced usage
+
+`Rainbow()` and `Rainbow.enabled` operate on the global Rainbow wrapper
+instance. If you would like to selectively enable/disable coloring in separate
+parts of your application you can get a new Rainbow wrapper instance for each
+of them and control the state of coloring during the runtime.
+
+```ruby
+rainbow_one = Rainbow.new
+rainbow_two = Rainbow.new
+
+rainbow_one.enabled = false
+
+Rainbow("hello").red          # => "\e[31mhello\e[0m" ("hello" if not on TTY)
+rainbow_one.wrap("hello").red # => "hello"
+rainbow_two.wrap("hello").red # => "\e[31mhello\e[0m" ("hello" if not on TTY)
+```
+
+By default each new instance inherits enabled/disabled state from the global
+`Rainbow.enabled`.
+
+This feature comes handy for example when you have multiple output formatters
+in your application and some of them print to a terminal but others write to a
+file. Normally rainbow would detect that STDIN/STDERR is a TTY and would
+colorize all the strings, even the ones that go through file writing
+formatters. You can easily solve that by disabling coloring for the Rainbow
+instances that are used by formatters with file output.
+
+## Installation
+
+Add it to your Gemfile:
+
+```ruby
+gem 'rainbow'
+```
+
+Or just install it via rubygems:
+
+```ruby
+gem install rainbow
+```
+
+## Color list
+
+### ANSI colors
+
+`black`, `red`, `green`, `yellow`, `blue`, `magenta`, `cyan`, `white`
+
+### X11 colors
+
+`aliceblue`, `antiquewhite`, `aqua`, `aquamarine`, `azure`, `beige`, `bisque`,
+`blanchedalmond`, `blueviolet`, `brown`, `burlywood`, `cadetblue`, `chartreuse`,
+`chocolate`, `coral`, `cornflower`, `cornsilk`, `crimson`, `darkblue`,
+`darkcyan`, `darkgoldenrod`, `darkgray`, `darkgreen`, `darkkhaki`,
+`darkmagenta`, `darkolivegreen`, `darkorange`, `darkorchid`, `darkred`,
+`darksalmon`, `darkseagreen`, `darkslateblue`, `darkslategray`, `darkturquoise`,
+`darkviolet`, `deeppink`, `deepskyblue`, `dimgray`, `dodgerblue`, `firebrick`,
+`floralwhite`, `forestgreen`, `fuchsia`, `gainsboro`, `ghostwhite`, `gold`,
+`goldenrod`, `gray`, `greenyellow`, `honeydew`, `hotpink`, `indianred`,
+`indigo`, `ivory`, `khaki`, `lavender`, `lavenderblush`, `lawngreen`,
+`lemonchiffon`, `lightblue`, `lightcoral`, `lightcyan`, `lightgoldenrod`,
+`lightgray`, `lightgreen`, `lightpink`, `lightsalmon`, `lightseagreen`,
+`lightskyblue`, `lightslategray`, `lightsteelblue`, `lightyellow`, `lime`,
+`limegreen`, `linen`, `maroon`, `mediumaquamarine`, `mediumblue`,
+`mediumorchid`, `mediumpurple`, `mediumseagreen`, `mediumslateblue`,
+`mediumspringgreen`, `mediumturquoise`, `mediumvioletred`, `midnightblue`,
+`mintcream`, `mistyrose`, `moccasin`, `navajowhite`, `navyblue`, `oldlace`,
+`olive`, `olivedrab`, `orange`, `orangered`, `orchid`, `palegoldenrod`,
+`palegreen`, `paleturquoise`, `palevioletred`, `papayawhip`, `peachpuff`,
+`peru`, `pink`, `plum`, `powderblue`, `purple`, `rebeccapurple`, `rosybrown`,
+`royalblue`, `saddlebrown`, `salmon`, `sandybrown`, `seagreen`, `seashell`,
+`sienna`, `silver`, `skyblue`, `slateblue`, `slategray`, `snow`, `springgreen`,
+`steelblue`, `tan`, `teal`, `thistle`, `tomato`, `turquoise`, `violet`,
+`webgray`, `webgreen`, `webmaroon`, `webpurple`, `wheat`, `whitesmoke`,
+`yellowgreen`
+
+## Authors
+
+[Marcin Kulik](http://ku1ik.com/) and [great open-source contributors](https://github.com/sickill/rainbow/graphs/contributors).

data/lib/soundly.rb

@@ -1,9 +1,12 @@
 #Environment
-require_relative "./soundly/version.rb"
-require_relative "./soundly/cli.rb"
-require_relative "soundly/tracks.rb"
-
 require 'pry'
+require 'rainbow'
+require 'net/ping'
 require 'rspotify'
-# require 'colorize'
-# require 'colorized_string'
+require 'dotenv/load'
+
+module Soundly
+  require_relative "./soundly/version.rb"
+  require_relative "./soundly/cli.rb"
+  require_relative "soundly/tracks.rb"
+end

data/lib/soundly/cli.rb

@@ -1,59 +1,93 @@
-require 'rspotify'
-require 'pry'
-require_relative 'tracks'
-
 class Soundly::CLI
+	def up?
+		if Net::Ping::External.new("www.google.com").ping? == true
+			true
+		end
+	end
+	def pass_go
+		if !up?
+			puts "You need an internet connection to run this program..."
+			puts "As if I needed to tell you that."
+			puts "Good bye for now, human."
+			exit
+		else
+			@@pills = Soundly::Tracks.new
+			menu
+		end
+	end
+
 	def call
-		pills
-		greetings
-		menu
-		goodbye
+		pass_go
 	end
 
-	def pills
-		@@pills = Soundly::Tracks.new
+	def menu
+		user_input = nil
+
+		greetings
+		puts Rainbow("Main Menu").green
+		puts Rainbow("Blue Pill").blue + " or" + Rainbow(" Red Pill").red + " or Exit?"
+
+		while user_input != "exit"
+			user_input = gets.strip.downcase
+			if user_input == "exit" || user_input == "3"
+				goodbye
+			elsif user_input == "blue" || user_input == "blue pill" || user_input == "1"
+				blue_pill
+			elsif user_input == "red" || user_input == "red pill" || user_input == "2"
+				red_pill
+			else
+				puts "Come again?"
+			end
+		end
 	end
 
 	def greetings
-		string = printf %Q(Greetings human. Lend me your earholes, I will fill them with beautiful sounds👽); sleep 1
-		print "\n"
-		printf %Q(You have options: Blue pill, or Red pill.)
+		puts %Q(Hey there...)
+		print %Q(You like music?)
+		puts %Q( Cool, me too.)
 		print "\n"
-		printf %Q(• The blue pill, allows you to sample a playlist shaped by your fellow homosapien's listening habits (top 50 currently trending songs on spotify).)
-		print "\n"
-		printf %Q(• Take the red pill, you get to sample an ever evolving playlist of sounds I fancy.)
 	end
 
-	def red_playlist
-		puts %Q(I like your style, hooman.)
-		puts %Q(Heres what I am currently listening to.)
-		@@pills.red_songs.each.with_index(1) {|object, index| puts "#{index}.  #{object.name} by #{object.artists[0].name} \n"}
+	def inner_playlist_options
+		puts " "
 		puts %Q(Type a song's listing number to learn more.)
 		puts %Q(Type "Menu" to head back to the main menu.)
+		puts %Q(Type exit to peace out.)
+		puts " "
+	end
+
+	def red_playlist
+		puts " "
+		puts %Q(Heres what I am currently listening to.)
+		@@pills.red_songs.each.with_index(1) do |song, song_index| 
+			puts "#{song_index}.  #{song.name} by #{song.artists[0].name} \n"
+		end
+		inner_playlist_options
 	end
 
 	def blue_playlist
-		puts %Q(:/ Okay, fine.)
+		puts %Q(America's top 50, coming up...)
 		puts "\n"
-		puts "Here's whats going on with music in your country, on planet E-Arth..."
-		@@pills.blue_songs.each.with_index(1) {|object, index| puts "#{index}.  #{object.name} by #{object.artists[0].name} \n"}
-		# binding.pry
-		puts %Q(Type a song's listing number to learn more.)
-		puts %Q(Type "Menu" to head back to the main menu.)
+		@@pills.blue_songs.each.with_index(1) do |song, song_index| 
+			puts "#{song_index}.  #{song.name} by #{song.artists[0].name}"
+		end
+			inner_playlist_options
 	end
 
 	def blue_pill
 		print "\n"
 		puts "Blue Pill: Main Menu"
-		sleep 1
 		blue_playlist
 
 		user_input = nil
 		while user_input != "menu"
-			user_input = gets.strip
+			user_input = gets.downcase.strip
 			if user_input == "menu"
 				menu
+			elsif user_input == "exit"
+				goodbye
 			elsif (1..50).to_a.include?(user_input.to_i)
+				puts " "
 				puts "Here are details on #{@@pills.blue_songs[user_input.to_i-1].name}"
 				song = @@pills.blue_songs[user_input.to_i-1]
 				puts "Song name:   #{song.name}"
@@ -62,19 +96,20 @@ class Soundly::CLI
 				puts "Duration:    #{song.duration_ms}"
 				puts "Popularity:  #{song.popularity}"
 				puts "Preview_url: #{song.preview_url}" if song.preview_url != nil
-				print "\n"
+				puts " "
+				puts "Would you like to select another song, Main Menu or Exit?"
 			else
-				puts %(You've lost me human. Try again.)
-				puts %(Select a number from the list to learn more about a song.)
-				print "\n"
-				puts %(Or you can type "Menu" to head back to main menu of course.)
-				print "\n"
+				puts %(Try again.)
+				puts " "
+				puts %(Select a number from the list, Menu or Exit)
+				puts " "
 			end
 		end
 	end
 
 	def red_pill
-		print "\n"
+		puts " "
+		puts %Q((I like your style human.))
 		puts "Red Pill: Main Menu"
 		red_playlist
 
@@ -82,10 +117,13 @@ class Soundly::CLI
 		while user_input != "menu"
 			user_input = gets.strip
 			object = @@pills.red_songs.count.to_i
-			# binding.pry
+
 			if user_input == "menu"
 				menu
+			elsif user_input == "exit"
+				goodbye
 			elsif (1..object).include?(user_input.to_i)
+				puts " "
 				puts "Here are details on #{@@pills.red_songs[user_input.to_i-1].name}"
 				song = @@pills.red_songs[user_input.to_i-1]
 				puts "Song name:   #{song.name}"
@@ -95,41 +133,18 @@ class Soundly::CLI
 				puts "Popularity:  #{song.popularity}"
 				puts "Preview_url: #{song.preview_url}" if song.preview_url != nil
 				print "\n"
+				puts "Would you like to select another song, go back to the Main Menu or Exit?"
 			else
-				puts %(You've lost me human. Try again.)
-				puts %(Select a number from the list to learn more about a song.)
-				print "\n"
-				puts %(Or you can type "Exit" to head back to main menu or course.)
+				puts %(Try again.)
+				print " \n"
+				puts %(Select a number from the list, "Menu" or "Exit")
 				print "\n"
 			end
 		end
 	end
 
-	def menu
-		user_input = nil
-		puts "Main Menu"
-		puts %Q(Type "Blue" for the Blue pill, and "Red" for the Red pill.)
-		puts %Q(Type "Exit" to part ways.)
-		print "\n"
-		puts %Q(Choose wisely, human...)
-
-		while user_input != "exit"
-			user_input = gets.strip.downcase
-			if user_input == "exit"
-				goodbye
-			elsif user_input == "blue"
-				blue_pill
-			elsif user_input == "red"
-				red_pill
-			else
-				puts "Come again?"
-			end
-		end
-	end
-
 	def goodbye
-		puts %Q(Goodbye human.)
-		puts %Q(See you soon.)
+		puts %Q(Peace out.)
 		exit
 	end
-end
+end

data/lib/soundly/tracks.rb

@@ -1,31 +1,35 @@
-require 'rspotify'
-require 'pry'
-require_relative 'cli'
-
 class Soundly::Tracks
-	# attr_accessor :track_name, :artist, :album, :genre, :duration, :popularity, :position, :preview_url
-
 	@@blue_playlist = []
 	@@red_playlist = []
-
+	@@all = []
+	
+	def authenticate #LOG IN
+		RSpotify.authenticate(ENV['CLIENT_ID'], ENV['CLIENT_SECRET'])
+	end
+	
+	def self.all(playlist)
+		if playlist == "blue"
+			@@blue_playlist
+		else
+			@@red_playlist
+		end
+	end
 
 	def initialize
 		blue_playlist
 		red_playlist
   end
 
-	def blue_playlist
-		RSpotify.authenticate("b866a06729ba441d8819fe317fa0d8b3", "f00fcf04738f4f73a8e880923f767a13")
+	def blue_playlist #SPOTIFY TOP 50 IN AMERICA
+		authenticate
 		playlist = RSpotify::Playlist.find('spotifycharts', '37i9dQZEVXbLRQDuF5jeBp')
 		playlist.tracks.each do |song|
 			@@blue_playlist  << song
-
-			#Soundly::Tracks.save_song(song)
 		end
 	end
 
-	def red_playlist
-		RSpotify.authenticate("b866a06729ba441d8819fe317fa0d8b3", "f00fcf04738f4f73a8e880923f767a13")
+	def red_playlist #MY PERSONAL SPOTIFY PLAYLIST
+		authenticate
 		playlist = RSpotify::Playlist.find('dwyn.hrmn', '7BQJkBkL5muBFOc7ok76XO')
 		playlist.tracks.each do |song|
 			@@red_playlist  << song
@@ -39,13 +43,4 @@ class Soundly::Tracks
 	def red_songs
 		@@red_playlist
 	end
-
-	def self.all(playlist)
-		if playlist == blue
-			@@blue_playlist
-		else
-			@@red_playlist
-		end
-	end
-
 end

data/lib/soundly/version.rb

@@ -1,3 +1,3 @@
 module Soundly
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/rspotify.md

@@ -0,0 +1,255 @@
+# RSpotify
+
+[![Gem Version](https://badge.fury.io/rb/rspotify.svg)](http://badge.fury.io/rb/rspotify)
+[![Build Status](https://travis-ci.org/guilhermesad/rspotify.svg?branch=master)](https://travis-ci.org/guilhermesad/rspotify)
+
+This is a ruby wrapper for the [Spotify Web API](https://developer.spotify.com/web-api).
+
+## Features
+
+* [Full documentation](http://www.rubydoc.info/github/guilhermesad/rspotify/master)
+* Full API Endpoint coverage
+* OAuth and other authorization flows
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rspotify'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rspotify
+
+## Usage
+
+RSpotify was designed with usability as its primary goal, so that you can forget the API and intuitively interact with your playlists, favorite artists, users and so on.
+
+You can write things like `my_playlist.tracks.sort_by(&:popularity).last.album` without having to think which API calls must be done. RSpotify fills the gaps for you.
+
+Below are some basic usage examples. Check the [documentation](http://rdoc.info/github/guilhermesad/rspotify/master/frames) for the complete reference.
+
+```ruby
+require 'rspotify'
+
+artists = RSpotify::Artist.search('Arctic Monkeys')
+
+arctic_monkeys = artists.first
+arctic_monkeys.popularity      #=> 74
+arctic_monkeys.genres          #=> ["Alternative Pop/Rock", "Indie", ...]
+arctic_monkeys.top_tracks(:US) #=> (Track array)
+
+albums = arctic_monkeys.albums
+albums.first.name #=> "AM"
+
+am = albums.first
+am.release_date      #=> "2013-09-10"
+am.images            #=> (Image array)
+am.available_markets #=> ["AR", "BO", "BR", ...]
+
+tracks = am.tracks
+tracks.first.name #=> "Do I Wanna Know?"
+
+do_i_wanna_know = tracks.first
+do_i_wanna_know.duration_ms  #=> 272386
+do_i_wanna_know.track_number #=> 1
+do_i_wanna_know.preview_url  #=> "https://p.scdn.co/mp3-preview/<id>"
+
+playlists = RSpotify::Playlist.search('Indie')
+playlists.first.name #=> "The Indie Mix"
+
+# You can search within other types too
+albums = RSpotify::Album.search('The Wall')
+tracks = RSpotify::Track.search('Thriller')
+```
+
+Find by id:
+
+```ruby
+arctic_monkeys = RSpotify::Artist.find('7Ln80lUS6He07XvHI8qqHH')
+arctic_monkeys.related_artists #=> (Artist array)
+
+am = RSpotify::Album.find('41vPD50kQ7JeamkxQW7Vuy')
+am.album_type #=> "single"
+
+do_i_wanna_know = RSpotify::Track.find('2UzMpPKPhbcC8RbsmuURAZ')
+do_i_wanna_know.album #=> (Album object)
+
+me = RSpotify::User.find('guilhermesad')
+me.uri #=> "spotify:user:guilhermesad"
+
+# Or find several objects at once:
+
+ids = %w(2UzMpPKPhbcC8RbsmuURAZ 7Jzsc04YpkRwB1zeyM39wE)
+
+my_tracks = RSpotify::Track.find(ids)
+my_tracks.size #=> 2
+```
+
+Some data require authentication to be accessed, such as playlists' details. You can easily get your credentials [here](https://developer.spotify.com/my-applications).
+
+Then just copy and paste them like so:
+
+```ruby
+RSpotify.authenticate("<your_client_id>", "<your_client_secret>")
+
+# Now you can access playlists in detail, browse featured content and more
+
+me = RSpotify::User.find('guilhermesad')
+me.playlists #=> (Playlist array)
+
+# Find by id
+playlist = RSpotify::Playlist.find('guilhermesad', '1Xi8mgiuHHPLQYOw2Q16xv')
+playlist.name               #=> "d33p"
+playlist.description        #=> "d33p h0uz"
+playlist.followers['total'] #=> 1
+playlist.tracks             #=> (Track array)
+
+# Search by category
+party = RSpotify::Category.find('party')
+party.playlists #=> (Playlist array)
+categories = RSpotify::Category.list # See all available categories
+
+# Access featured content from Spotify's Browse tab
+featured_playlists = RSpotify::Playlist.browse_featured(country: 'US')
+new_releases = RSpotify::Album.new_releases(country: 'ES')
+
+# Access tracks' audio features
+sorry = RSpotify::Track.search("Sorry").first
+sorry.audio_features.danceability #=> 0.605
+sorry.audio_features.energy #=> 0.768
+sorry.audio_features.tempo #=> 100.209
+
+# Get recommendations
+recommendations = RSpotify::Recommendations.generate(seed_genres: ['blues', 'country'])
+recommendations = RSpotify::Recommendations.generate(seed_tracks: my_fav_tracks.map(&:id))
+recommendations = RSpotify::Recommendations.generate(seed_artists: my_fav_artists.map(&:id))
+recommendations.tracks #=> (Track array)
+```
+
+## Rails + OAuth
+
+You might want your application to access a user's Spotify account.
+
+For instance, suppose you want your app to create playlists for the user based on their taste, or to add a feature that syncs user's playlists with some external app.
+
+If so, add the following to your application (Remember to [get your credentials](https://developer.spotify.com/my-applications))
+
+```ruby
+# config/application.rb
+
+RSpotify::authenticate("<your_client_id>", "<your_client_secret>")
+```
+
+```ruby
+# config/initializers/omniauth.rb
+
+require 'rspotify/oauth'
+
+Rails.application.config.middleware.use OmniAuth::Builder do
+  provider :spotify, "<your_client_id>", "<your_client_secret>", scope: 'user-read-email playlist-modify-public user-library-read user-library-modify'
+end
+```
+
+You should replace the scope values for the ones your own app will require from the user. You can see the list of available scopes in [here](https://developer.spotify.com/web-api/using-scopes).
+
+Next, make a link so the user can log in with his Spotify account:
+
+```ruby
+<%= link_to 'Sign in with Spotify', '/auth/spotify' %>
+```
+
+And create a route to receive the callback:
+
+```ruby
+# config/routes.rb
+
+get '/auth/spotify/callback', to: 'users#spotify'
+```
+
+Remember you need to tell Spotify this address is white-listed. You can do this by adding it to the Redirect URIs list in your [application page](https://developer.spotify.com/my-applications). An example of Redirect URI would be http://localhost:3000/auth/spotify/callback.
+
+Finally, create a new RSpotify User with the response received:
+
+```ruby
+class UsersController < ApplicationController
+  def spotify
+    spotify_user = RSpotify::User.new(request.env['omniauth.auth'])
+    # Now you can access user's private data, create playlists and much more
+
+    # Access private data
+    spotify_user.country #=> "US"
+    spotify_user.email   #=> "example@email.com"
+
+    # Create playlist in user's Spotify account
+    playlist = spotify_user.create_playlist!('my-awesome-playlist')
+
+    # Add tracks to a playlist in user's Spotify account
+    tracks = RSpotify::Track.search('Know')
+    playlist.add_tracks!(tracks)
+    playlist.tracks.first.name #=> "Somebody That I Used To Know"
+
+    # Access and modify user's music library
+    spotify_user.save_tracks!(tracks)
+    spotify_user.saved_tracks.size #=> 20
+    spotify_user.remove_tracks!(tracks)
+
+    albums = RSpotify::Album.search('launeddas')
+    spotify_user.save_albums!(albums)
+    spotify_user.saved_albums.size #=> 10
+    spotify_user.remove_albums!(albums)
+
+    # Use Spotify Follow features
+    spotify_user.follow(playlist)
+    spotify_user.follows?(artists)
+    spotify_user.unfollow(users)
+
+    # Get user's top played artists and tracks
+    spotify_user.top_artists #=> (Artist array)
+    spotify_user.top_tracks(time_range: 'short_term') #=> (Track array)
+
+    # Check doc for more
+  end
+end
+```
+
+The user's access token is automatically refreshed by RSpotify when needed. This is specially useful if you persist the user data on a database: this way he only needs to log in to Spotify once in his entire use of your application.
+
+RSpotify provides a way to facilitate persistence:
+
+```ruby
+hash = spotify_user.to_hash
+# hash containing all user attributes, including access tokens
+
+# Use the hash to persist the data the way you prefer...
+
+# Then recover the Spotify user whenever you like
+spotify_user = RSpotify::User.new(hash)
+spotify_user.create_playlist!('my_awesome_playlist') # automatically refreshes token
+```
+
+## Getting raw response
+
+To get the raw response from Spotify API requests, just toggle the `raw_response` variable:
+
+```ruby
+RSpotify.raw_response = true
+RSpotify::Artist.search('Cher') #=> (String with raw json response)
+```
+
+## Notes
+
+If you'd like to use OAuth outside rails, have a look [here](https://developer.spotify.com/web-api/authorization-guide/#authorization_code_flow) for the requests that need to be made. You should be able to pass the response to RSpotify::User.new just as well, and from there easily create playlists and more for your user.
+
+## Contributing
+
+1. Fork it ( https://github.com/guilhermesad/rspotify/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Test your changes (`bundle exec rspec`)
+4. Commit your changes (`git commit -am 'Add some feature'`)
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create a new Pull Request

data/soundly.gemspec

@@ -25,9 +25,10 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.14"
   spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency	"rspotify"
-	spec.add_development_dependency "spotify-client"
-	spec.add_development_dependency "omniauth-spotify"
   spec.add_development_dependency "pry"
-end
+  spec.add_development_dependency "rspec", "~> 3.2"
+  spec.add_dependency "net-ping"
+  spec.add_dependency "dotenv"
+  spec.add_dependency	"rspotify"
+  spec.add_dependency "rainbow"
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: soundly
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - "<dwyn>"
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-06-18 00:00:00.000000000 Z
+date: 2018-01-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,28 +38,42 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.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'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.2'
 - !ruby/object:Gem::Dependency
-  name: rspotify
+  name: net-ping
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -67,13 +81,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: spotify-client
+  name: dotenv
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -81,13 +95,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: omniauth-spotify
+  name: rspotify
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -95,13 +109,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: pry
+  name: rainbow
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -122,6 +136,7 @@ files:
 - CODE_OF_CONDUCT.md
 - Gemfile
 - README.md
+- Rainbow.md
 - Rakefile
 - bin/console
 - bin/setup
@@ -132,6 +147,7 @@ files:
 - lib/soundly/tracks.rb
 - lib/soundly/version.rb
 - notes.md
+- rspotify.md
 - soundly.gemspec
 - spec.md
 homepage: https://github.com/dwyn/soundly
@@ -153,7 +169,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.6.14
 signing_key: 
 specification_version: 4
 summary: This gem will play songs from a revolving playlist through the Spotify API