soundly 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 982a1a80bc9696fc2a87fde99ad336371b01b04a
-  data.tar.gz: 630fbde11a7f552b0ea8b5338bf70ca1abb2cf88
+SHA256:
+  metadata.gz: b7a95dd1aec19a430993c0132ca412e0b0b6ff5c0d09cd53fd67dd70e42d5375
+  data.tar.gz: 3e1fce6eb45557df5ba0985033e4bb0f2def779bd7f4f98b3ded5e6f7398c6b5
 SHA512:
-  metadata.gz: f6b97db82e320dd6c264765a491cc3ea490ae4ebaf7171f50329523923af41507ff1279900df2528a801e72df92376a138c55b08462572e8ee82fee97c3f0095
-  data.tar.gz: a0ed2fb4a3b79a8fa58575c525bfe5fa3188cb8b5e8dd0f7fe22d1c7f0afbaa7d33f0c1429e91d638a3e025f75856854388d0e73023596451d646ec1aa96f147
+  metadata.gz: 5fcdf5d123ee6be530fde44632d090e1005eaf105e4d901ff3ae6d9f555a05dbd332ba3fd9fb22cbd17390a65daa8f4a7bc7f873a862e25a772d3a05c4b6b249
+  data.tar.gz: 550f2c073b575abb845dfe74cd6b29815cf041b84fdd0afd839c33dd54b172ba42fd16b3772fa2951b97c9d48f538f63d1861d97f31031f9ab46b883064d6501

data/README.md

@@ -1,33 +1,11 @@
 # Soundly
-
-Soundly will offer two playlists generated through Spotify's API. The first playlist will be the 50 most played songs in the united states; the second playlist will be a user curated playlist. The user is me and the playlist is comprised of the songs I listen to most at any given moment.
+Soundly will offer two playlists generated through Spotify's Ruby API. The first playlist will be the 50 most played songs in the united states; the second playlist will be a user curated playlist. The user is me and the playlist is comprised of the songs I listen to most at any given moment.
 
 ## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'soundly'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install soundly
+run `$ gem install soundly`
 
 ## Usage
-
-Pretty straight forward. This gem is just for funsies.
-
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+Pretty straightforward. This gem is just for funsies.
 
 ## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/<github username>/soundly. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on GitHub at https://github.com/dwyn/soundly. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.

data/bin/soundly

@@ -2,5 +2,5 @@
 require "bundler/setup"
 require "soundly"
 
-Soundly::CLI.new.call
+Soundly::CLI.new.start
  

data/lib/soundly/cli.rb

@@ -1,9 +1,10 @@
 class Soundly::CLI
+
 	def up?
-		if Net::Ping::External.new("www.google.com").ping? == true
-			true
-		end
+		true if Net::Ping::External.new("www.google.com").ping?
+		# binding.pry
 	end
+	
 	def pass_go
 		if !up?
 			puts "You need an internet connection to run this program..."
@@ -16,7 +17,7 @@ class Soundly::CLI
 		end
 	end
 
-	def call
+	def start
 		pass_go
 	end
 

data/lib/soundly/tracks.rb

@@ -30,7 +30,7 @@ class Soundly::Tracks
 
 	def red_playlist #MY PERSONAL SPOTIFY PLAYLIST
 		authenticate
-		playlist = RSpotify::Playlist.find('dwyn.hrmn', '7BQJkBkL5muBFOc7ok76XO')
+		playlist = RSpotify::Playlist.find('dwayne.', '2wbLPMQHxG3vhxQzRNEOm9')
 		playlist.tracks.each do |song|
 			@@red_playlist  << song
 		end

data/lib/soundly/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: soundly
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - "<dwyn>"
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-01-27 00:00:00.000000000 Z
+date: 2018-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -129,27 +129,20 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".DS_Store"
 - ".gitignore"
-- ".rspec"
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
 - README.md
-- Rainbow.md
 - Rakefile
 - bin/console
 - bin/setup
 - bin/soundly
-- lib/.DS_Store
 - lib/soundly.rb
 - lib/soundly/cli.rb
 - lib/soundly/tracks.rb
 - lib/soundly/version.rb
-- notes.md
-- rspotify.md
 - soundly.gemspec
-- spec.md
 homepage: https://github.com/dwyn/soundly
 licenses: []
 metadata: {}
@@ -169,7 +162,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: This gem will play songs from a revolving playlist through the Spotify API

data/.rspec

@@ -1,2 +0,0 @@
---format documentation
---color

data/Rainbow.md

@@ -1,224 +0,0 @@
-# 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/notes.md

@@ -1,10 +0,0 @@
-#Psuedo code for Soundly
-
-1. Greets user
-2. Give user choice between blue pill and red pill, or to exit the program completely.
-
-	2A. Blue pill will take user to Spotify's top 50 trending songs in USA
-
-	2B. Red pill will take user to my personal trending list on Spotify.
-
-3. Regardless of pill chosen, the program should end up in a loop that offers a list of songs available - followed by a prompt to ask the user if they would like detailed information on a specific song 

data/rspotify.md

@@ -1,255 +0,0 @@
-# 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/spec.md

@@ -1,6 +0,0 @@
-# Specifications for the CLI Assessment
-
-Specs:
-- [x] Have a CLI for interfacing with the application
-- [x] Pull data from an external source
-- [x] Implement both list and detail views