pandata 0.1.0.pre

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7f73c416a585d7b27a59799982502ab3425c0830
+  data.tar.gz: 88921adfb03392ac5af5f56402e1ef58e6cee767
+SHA512:
+  metadata.gz: 17a42cf2bf107425067d52db7139abe3bb96321cdd9cc16e9041ebe8b4641264e21dbbe8040f9a2fd5cf3df8af3c161f1d51aa60ccbefc5980ab7616b12806d3
+  data.tar.gz: 682286a820a8f4314fe399f201e6d5362929d4b823e3b0b2c44a2cb2c09f84f1441cc7d1c10271ddedb51978103c664d492292e74e5d209c1716b0e064d67844

data/bin/pandata

@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/pandata'
+require_relative '../lib/pandata/argv_parser'
+require_relative '../lib/pandata/data_formatter'
+
+options = Pandata::ArgvParser.parse(ARGV)
+
+output_file = options[:output_file]
+if output_file
+  File.delete(output_file) if File.exists?(output_file)
+
+  Object.send(:define_method, :write) do |string|
+    File.open(output_file, 'a') do |file|
+      file.write(string)
+    end
+  end
+else
+  def write(string)
+    puts string
+  end
+end
+
+if ARGV.empty?
+  # Print command-line usage help.
+  puts options[:opts]
+  exit
+end
+
+scraper = Pandata::Scraper.get(options[:user_id])
+formatter = Pandata::DataFormatter.new
+
+# If scraper is an array, a Pandora user could not be found with certainty.
+# In this case, scraper will contain webnames similar to options[:user_id].
+if scraper.kind_of?(Array)
+  puts "No exact match for '#{options[:user_id]}'."
+
+  unless scraper.empty?
+    puts "\nWebname results for '#{options[:user_id]}':"
+    puts formatter.list(scraper)
+  end
+
+  exit
+end
+
+scraper_data = {}
+options[:data_to_get].each do |data_type|
+  if /(bookmark|like)e?d_(.*)/ =~ data_type
+    method = $1 << 's'  # 'likes' or 'bookmarks'
+    argument = $2.to_sym  # :tracks, :artists, :stations or :albums
+    scraper_data[data_type] = scraper.public_send(method, argument)
+  else
+    scraper_data[data_type] = scraper.public_send(data_type)
+  end
+end
+
+if options[:return_as_json]
+  require 'json'
+  write JSON.generate(scraper_data)
+  exit
+end
+
+scraper_data.each do |key, value|
+  # Capitalize each word in the key symbol.
+  # e.g. :liked_tracks becomes 'Liked Tracks:'
+  title = key.to_s.split('_').map(&:capitalize).join(' ') << ':'
+
+  if value.empty?
+    output = '  ** No Data **'
+  else
+    output = case key
+             when /playing_station|recent_activity/
+               formatter.list(value)
+             when /liked_tracks|bookmarked_tracks/
+               formatter.tracks(value)
+             when /liked_artists|bookmarked_artists|stations|liked_stations/
+               formatter.sort_list(value)
+             when :liked_albums
+               formatter.albums(value)
+             when /following|followers/
+               formatter.followx(value)
+             end
+  end
+
+  write "#{ title }\n#{ output }"
+end

data/lib/pandata.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require_relative 'pandata/data_urls'
+require_relative 'pandata/downloader'
+require_relative 'pandata/parser'
+require_relative 'pandata/scraper'
+
+module Pandata
+  module Version
+    MAJOR = 0
+    MINOR = 1
+    PATCH = 0
+    BUILD = 'pre'
+
+    STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')
+  end
+end
+

data/lib/pandata/argv_parser.rb

@@ -0,0 +1,131 @@
+require 'optparse'
+require_relative '../pandata'
+
+module Pandata
+
+  # Parses command-line input.
+  class ArgvParser
+    # Prevent instances
+    private_class_method :new
+
+    # Takes an ARGV (array) argument.
+    #
+    # Returns a hash with:
+    # - :opts (OptionParser object)
+    # - :user_id (string)
+    # - :output_file (string)
+    # - :data_to_get (array)
+    # - :get_all_data (boolean)
+    # - :return_as_json (boolean)
+    def self.parse(argv)
+      options = { data_to_get: [] }
+      get_all_data = false
+
+      options[:opts] = OptionParser.new do |opts|
+        opts.banner = 'Pandata: A tool for downloading Pandora.com data (likes, bookmarks, stations, etc.)'
+        opts.define_head 'Usage: pandata <email|webname> [options]'
+        opts.separator <<-END
+
+Examples:
+  pandata john@example.com --liked_tracks
+  pandata my_webname --all -o my_pandora_data.txt
+  pandata my_webname -lLb --json
+
+Options:
+        END
+
+        opts.on('--all', 'Get all data') do
+          get_all_data = true
+        end
+
+        opts.on('-a', '--recent_activity', 'Get recent activity') do
+          options[:data_to_get] << :recent_activity
+        end
+
+        opts.on('-B', '--bookmarked_artists', 'Get all bookmarked artists') do
+          options[:data_to_get] << :bookmarked_artists
+        end
+
+        opts.on('-b', '--bookmarked_tracks', 'Get all bookmarked tracks') do
+          options[:data_to_get] << :bookmarked_tracks
+        end
+
+        opts.on('-F', '--followers', "Get all user's followers") do
+          options[:data_to_get] << :followers
+        end
+
+        opts.on('-f', '--following', 'Get all users being followed by user') do
+          options[:data_to_get] << :following
+        end
+
+        opts.on('-j', '--json', 'Return the results as JSON') do
+          options[:return_as_json] = true
+        end
+
+        opts.on('-L', '--liked_artists', 'Get all liked artists') do
+          options[:data_to_get] << :liked_artists
+        end
+
+        opts.on('-l', '--liked_tracks', 'Get all liked tracks') do
+          options[:data_to_get] << :liked_tracks
+        end
+
+        opts.on('-m', '--liked_albums', 'Get all liked albums') do
+          options[:data_to_get] << :liked_albums
+        end
+
+        opts.on('-n', '--liked_stations', 'Get all liked stations') do
+          options[:data_to_get] << :liked_stations
+        end
+
+        opts.on('-o', '--output_file PATH', 'File to output the data into') do |path|
+          options[:output_file] = path
+        end
+
+        opts.on('-S', '--playing_station', 'Get currently playing station') do
+          options[:data_to_get] << :playing_station
+        end
+
+        opts.on('-s', '--stations', 'Get all stations') do
+          options[:data_to_get] << :stations
+        end
+
+        opts.on_tail("-h", "--help", "Show this message") do
+          puts opts
+          exit
+        end
+
+        opts.on_tail("--version", "Show version") do
+          puts Pandata::Version::STRING
+          exit
+        end
+      end
+
+      options[:opts].parse(argv)
+
+      # User ID is the first argument.
+      options[:user_id] = argv.shift
+
+      if get_all_data
+        options[:data_to_get] = [
+          :recent_activity,
+          :playing_station,
+          :stations,
+          :bookmarked_tracks,
+          :bookmarked_artists,
+          :liked_tracks,
+          :liked_artists,
+          :liked_albums,
+          :liked_stations,
+          :followers,
+          :following
+        ]
+      else
+        # Remove any duplicates caused by supplying flags multiple times.
+        options[:data_to_get].uniq!
+      end
+
+      options
+    end
+  end
+end

data/lib/pandata/data_formatter.rb

@@ -0,0 +1,105 @@
+require 'set'
+
+module Pandata
+
+  # Sorts and formats Pandata::Scraper data as a string for printing.
+  class DataFormatter
+
+    # Takes an array or string and returns a string with each item on its own line.
+    #--
+    #
+    # Example output:
+    # - item1
+    # - item2
+    # - item3
+    #
+    #++
+    def list(data)
+      data = [data] unless data.kind_of?(Array)
+      str = ''
+      data.each { |item| str << "  - #{item}\n" }
+      str
+    end
+
+    # Identical to #list but sorts alphabetically ignoring 'the'.
+    def sort_list(data)
+      list custom_sort(data)
+    end
+
+    # Takes an array of hashes with :artist and :track keys.
+    def tracks(tracks)
+      artists_items(tracks, :track)
+    end
+
+    # Takes an array of hashes with :artist and :album keys.
+    def albums(albums)
+      artists_items(albums, :album)
+    end
+
+    # Takes an array of hashes with :name, :webname and :href keys.
+    def followx(data)
+      str = ''
+      data.sort_by { |item| item[:webname].downcase }.each do |hash|
+        str << "  - name: #{hash[:name]}\n"
+        str << "    webname: #{hash[:webname]}\n"
+        str << "    href: #{hash[:href]}\n"
+      end
+      str
+    end
+
+    private
+
+    # Takes an array or hash.
+    # Sorts alphabetically ignoring the initial 'The' when sorting strings.
+    # Also case-insensitive to prevent lowercase names from being sorted last.
+    def custom_sort(enumerable)
+      sorted_array = enumerable.sort_by { |key, _| key.sub(/^the\s*/i, '').downcase }
+
+      # sort_by() returns an array when called on hashes.
+      if enumerable.kind_of?(Hash)
+        # Rebuild the hash.
+        sorted_hash = {}
+        sorted_array.each { |item| sorted_hash[item[0]] = item[1] }
+        sorted_hash
+      else
+        sorted_array
+      end
+    end
+
+    # Takes an array of hashes with :artist and another key belonging to an
+    # artist (e.g. :track or :album).
+    # Returns a string with each artist name on a line with the artist's items
+    # listed and indented below. Sorts the output, too.
+    #--
+    #
+    # Example output:
+    # - Artist1:
+    #   - item2
+    #   - item3
+    # - Artist2:
+    #   - item1
+    #   - item1
+    #
+    #++
+    def artists_items(data, item_name)
+      artists_items = {}
+
+      data.each do |hash|
+        artist_name = hash[:artist]
+        (artists_items[artist_name] ||= Set.new) << hash[item_name]
+      end
+
+      artists_items = custom_sort(artists_items)
+
+      str = ''
+      artists_items.each do |artist_name, items|
+        str << "  - #{artist_name}\n"
+        custom_sort(items).each do |item|
+          str << "      - #{item}\n"
+        end
+      end
+      str
+    end
+
+  end
+end

data/lib/pandata/data_urls.rb

@@ -0,0 +1,20 @@
+module Pandata
+  # Number of results to get from a feeds.pandora.com URL.
+  MAX_RESULTS = 100000  # Get everything...
+
+  # URLs to Pandora's data!
+  DATA_FEED_URLS = {
+    user_search:          'http://www.pandora.com/content/connect?searchString=%{searchString}',
+    recent_activity:      'http://feeds.pandora.com/feeds/people/%{webname}/recentactivity.xml',
+    playing_station:      'http://feeds.pandora.com/feeds/people/%{webname}/nowplaying.xml',
+    stations:             "http://feeds.pandora.com/feeds/people/%{webname}/stations.xml?max=#{MAX_RESULTS}",
+    bookmarked_tracks:    "http://feeds.pandora.com/feeds/people/%{webname}/favorites.xml?max=#{MAX_RESULTS}",
+    bookmarked_artists:   "http://feeds.pandora.com/feeds/people/%{webname}/favoriteartists.xml?max=#{MAX_RESULTS}",
+    liked_tracks:         'http://www.pandora.com/content/tracklikes?likeStartIndex=%{nextLikeStartIndex}&thumbStartIndex=%{nextThumbStartIndex}&webname=%{webname}',
+    liked_artists:        'http://www.pandora.com/content/artistlikes?artistStartIndex=%{nextStartIndex}&webname=%{webname}',
+    liked_stations:       'http://www.pandora.com/content/stationlikes?stationStartIndex=%{nextStartIndex}&webname=%{webname}',
+    liked_albums:         'http://www.pandora.com/content/albumlikes?albumStartIndex=%{nextStartIndex}&webname=%{webname}',
+    following:            'http://www.pandora.com/content/following?startIndex=%{nextStartIndex}&webname=%{webname}',
+    followers:            'http://www.pandora.com/content/followers?startIndex=%{nextStartIndex}&webname=%{webname}'
+  }
+end

data/lib/pandata/downloader.rb

@@ -0,0 +1,56 @@
+require 'json'
+require 'open-uri'
+
+module Pandata
+  # Custom Pandata error
+  class PandataError < StandardError
+  end
+
+  # Retrieves data from Pandora and handles errors.
+  class Downloader
+    # A GitHub Gist that contains an updated cookie allowing access to 'login-only' visible data.
+    CONFIG_URL = 'https://gist.github.com/ustasb/596f1ee96d03463fde77/raw/pandata_config.json'
+
+    class << self
+      attr_accessor :cookie
+    end
+
+    # Gets a Pandora cookie and returns a Downloader instance.
+    def initialize
+      # If we already have a cookie, don't get another.
+      unless Downloader.cookie
+        Downloader.cookie = get_cookie
+      end
+    end
+
+    # Downloads a page and returns its content as a string.
+    def read_page(url)
+      download(url, Downloader.cookie).read
+    end
+
+    private
+
+    # Downloads a page and handles errors.
+    def download(url, cookie = '')
+      escaped_url = URI.escape(url)
+
+      begin
+        open(escaped_url, 'Cookie' => cookie, :read_timeout => 5)
+      rescue OpenURI::HTTPError => error
+        puts "The network request for:\n  #{url}\nreturned an error:\n  #{error.message}"
+        puts "Please try again later or update Pandata. Sorry about that!\n\nFull error:"
+        raise PandataError
+      end
+    end
+
+    def get_cookie
+      config = JSON.parse download(CONFIG_URL).read
+
+      if Gem::Version.new(Pandata::Version::STRING) <= Gem::Version.new(config['required_update_for'])
+        raise PandataError, 'Pandora.com has changed something and you need to update Pandata!'
+      end
+
+      config['cookie']
+    end
+  end
+end

data/lib/pandata/parser.rb

@@ -0,0 +1,191 @@
+require 'nokogiri'
+
+module Pandata
+
+  # Parses HTML/XML pages from Pandora for relevant data.
+  class Parser
+
+    # Returns an array of webnames.
+    def get_webnames_from_search(html)
+      user_links = Nokogiri::HTML(html).css('.user_name a')
+      webnames = []
+
+      user_links.each do |link|
+        webnames << link['webname']
+      end
+
+      webnames
+    end
+
+    # Returns the query parameters necessary to get the next page of data
+    # from Pandora.
+    def get_next_data_indices(html)
+      show_more = Nokogiri::HTML(html).css('.show_more')[0]
+
+      if show_more
+        next_indices = {}
+        data_attributes = ['nextStartIndex', 'nextLikeStartIndex', 'nextThumbStartIndex']
+        data_attributes.each do |attr_name|
+          attr = show_more.attributes['data-' + attr_name.downcase]
+          next_indices[attr_name.to_sym] = attr.value.to_i if attr
+        end
+
+        next_indices
+      else
+        false
+      end
+    end
+
+    # Returns an array of recent activities.
+    def get_recent_activity(xml)
+      activity_names = []
+
+      xml_each_item(xml) do |title|
+        activity_names << title
+      end
+
+      activity_names
+    end
+
+    # Returns an array of station names.
+    def get_stations(xml)
+      stations = []
+
+      xml_each_item(xml) do |title|
+        stations << title
+      end
+
+      stations
+    end
+
+    # Returns the currently playing station name.
+    def get_playing_station(xml)
+      station = ''
+
+      xml_each_item(xml) do |title|
+        station = title  # First title is the station name.
+        break
+      end
+
+      station
+    end
+
+    # Returns an array of hashes with :artist and :track keys.
+    def get_bookmarked_tracks(xml)
+      tracks = []
+
+      xml_each_item(xml) do |title|
+        track, artist = title.split(' by ')
+        tracks << { artist: artist, track: track }
+      end
+
+      tracks
+    end
+
+    # Returns an array of artist names.
+    def get_bookmarked_artists(xml)
+      artists = []
+
+      xml_each_item(xml) do |title|
+        artists << title
+      end
+
+      artists
+    end
+
+    # Returns an array of hashes with :artist and :track keys.
+    def get_liked_tracks(html)
+      tracks = []
+
+      infobox_each_link(html) do |title, subtitle|
+        tracks << { track: title, artist: subtitle }
+      end
+
+      tracks
+    end
+
+    # Returns an array of artist names.
+    def get_liked_artists(html)
+      get_infobox_titles(html)
+    end
+
+    # Returns an array of station names.
+    def get_liked_stations(html)
+      get_infobox_titles(html)
+    end
+
+    # Returns an array of hashes with :artist and :album keys.
+    def get_liked_albums(html)
+      albums = []
+
+      infobox_each_link(html) do |title, subtitle|
+        albums << { album: title, artist: subtitle }
+      end
+
+      albums
+    end
+
+    # Returns an array of hashes with :name, :webname and :href keys.
+    def get_following(html)
+      get_followx_users(html)
+    end
+
+    # Returns an array of hashes with :name, :webname and :href keys.
+    def get_followers(html)
+      get_followx_users(html)
+    end
+
+    private
+
+    # Loops over each 'item' tag and yields the title and description.
+    def xml_each_item(xml)
+      Nokogiri::XML(xml).css('item').each do |item|
+        title = item.at_css('title').text
+        desc = item.at_css('description').text
+        yield(title, desc)
+      end
+    end
+
+    # Loops over each .infobox container and yields the title and subtitle.
+    def infobox_each_link(html)
+      Nokogiri::HTML(html).css('.infobox').each do |infobox|
+        infobox_body = infobox.css('.infobox-body')
+
+        title_link = infobox_body.css('h3 a').text.strip
+        subtitle_link = infobox_body.css('p a').first
+        subtitle_link = subtitle_link.text.strip if subtitle_link
+
+        yield(title_link, subtitle_link)
+      end
+    end
+
+    # Returns an array of titles from #infobox_each_link.
+    def get_infobox_titles(html)
+      titles = []
+      infobox_each_link(html) { |title| titles << title }
+      titles
+    end
+
+    # Loops over each .follow_section container and returns a hash with
+    # :name, :webname and :href keys.
+    def get_followx_users(html)
+      users = []
+
+      Nokogiri::HTML(html).css('.follow_section').each do |section|
+        listener_name = section.css('.listener_name').first
+        webname = listener_name['webname']
+
+        # Remove any 'spans with a space' that sometimes appear with special characters.
+        listener_name.css('span').each(&:remove)
+        name = listener_name.text.strip
+
+        href = section.css('a').first['href']
+
+        users << { name: name, webname: webname, href: href }
+      end
+
+      users
+    end
+
+  end
+end

data/lib/pandata/scraper.rb

@@ -0,0 +1,165 @@
+require_relative 'data_urls'
+require_relative 'parser'
+require_relative 'downloader'
+
+module Pandata
+
+  # Downloads a user's Pandora.com data.
+  # A user's profile must be public for Pandata to download its data.
+  class Scraper
+
+    # What Pandora uses to identify a user and it remains constant even if
+    # the user ties a new email address to their Pandora account.
+    attr_reader :webname
+
+    # Takes either an email or a webname string.
+    # Returns either:
+    # - a new scraper object for the supplied user ID.
+    # - an array of similar webnames because a matching Pandora user could not be found.
+    def self.get(user_id)
+      search_url = DATA_FEED_URLS[:user_search] % { searchString: user_id }
+      html = Downloader.new.read_page(search_url)
+      webnames = Parser.new.get_webnames_from_search(html)
+
+      if webnames.include?(user_id)
+        new(user_id)
+      # If user_id looks like an email and still gets a result.
+      elsif webnames.size == 1 && /.*@.*\..*/ =~ user_id
+        new(webnames.first)
+      else
+        webnames
+      end
+    end
+
+    private_class_method :new
+    def initialize(webname)
+      @downloader = Downloader.new
+      @parser = Parser.new
+      @webname = webname
+    end
+
+    # Returns an array of the user's recent activity.
+    def recent_activity
+      scrape_for(:recent_activity, :get_recent_activity)
+    end
+
+    # Returns the user's currently playing station.
+    def playing_station
+      scrape_for(:playing_station, :get_playing_station).first
+    end
+
+    # Returns an array of the user's stations.
+    def stations
+      scrape_for(:stations, :get_stations)
+    end
+
+    # Returns a user's bookmarked data.
+    #
+    # Bookmark types:
+    # - :artists - Returns an array of artist names.
+    # - :tracks - Returns an array of hashes with :artist and :track keys.
+    # - :all - Returns a hash with all bookmarked data.
+    def bookmarks(bookmark_type = :all)
+      case bookmark_type
+      when :tracks
+        scrape_for(:bookmarked_tracks, :get_bookmarked_tracks)
+      when :artists
+        scrape_for(:bookmarked_artists, :get_bookmarked_artists)
+      when :all
+        { artists: bookmarks(:artists),
+          tracks: bookmarks(:tracks) }
+      end
+    end
+
+    # Returns a user's liked data. (The results from giving a 'thumbs up.')
+    #
+    # Like types:
+    # - :artists - Returns an array of artist names.
+    # - :albums - Returns an array of album names.
+    # - :stations - Returns an array of station names.
+    # - :tracks - Returns an array of hashes with :artist and :track keys.
+    # - :all - Returns a hash with all liked data.
+    def likes(like_type = :all)
+      case like_type
+      when :tracks
+        scrape_for(:liked_tracks, :get_liked_tracks)
+      when :artists
+        scrape_for(:liked_artists, :get_liked_artists)
+      when :stations
+        scrape_for(:liked_stations, :get_liked_stations)
+      when :albums
+        scrape_for(:liked_albums, :get_liked_albums)
+      when :all
+        { artists: likes(:artists),
+          albums: likes(:albums),
+          stations: likes(:stations),
+          tracks: likes(:tracks) }
+      end
+    end
+
+    # Returns the *public* users being followed by the user.
+    #
+    # Returns an array of hashes with keys:
+    # - :name - Profile name
+    # - :webname - Unique Pandora ID
+    # - :href - URL to online Pandora profile.
+    def following
+      scrape_for(:following, :get_following)
+    end
+
+    # Returns the user's followers in a format identical to #following.
+    def followers
+      scrape_for(:followers, :get_followers)
+    end
+
+    private
+
+    # Downloads all data for a given type, calls the supplied Pandata::Parser
+    # method and removes any duplicates.
+    def scrape_for(data_type, parser_method)
+      results = []
+
+      url = get_url(data_type)
+      download_all_data(url) do |html, next_data_indices|
+        new_data = @parser.public_send(parser_method, html)
+
+        if new_data.kind_of?(Array)
+          results.concat(new_data)
+        else
+          results.push(new_data)
+        end
+
+        get_url(data_type, next_data_indices) if next_data_indices
+      end
+
+      # Pandora data often contains duplicates--get rid of them.
+      results.uniq
+    end
+
+    # Downloads all data given a starting URL. Some Pandora feeds only return
+    # 5 - 10 items per page but contain a link to the next set of data. Threads
+    # cannot be used because page A be must visited to know how to obtain page B.
+    def download_all_data(url)
+      next_data_indices = {}
+
+      while next_data_indices
+        html = @downloader.read_page(url)
+        next_data_indices = @parser.get_next_data_indices(html)
+        url = yield(html, next_data_indices)
+      end
+    end
+
+    # Grabs a URL from DATA_FEED_URLS and formats it appropriately.
+    def get_url(data_name, next_data_indices = {})
+      next_data_indices = {
+        nextStartIndex: 0,
+        nextLikeStartIndex: 0,
+        nextThumbStartIndex: 0
+      } if next_data_indices.empty?
+
+      next_data_indices[:webname] = @webname
+      DATA_FEED_URLS[data_name] % next_data_indices
+    end
+
+  end
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: pandata
+version: !ruby/object:Gem::Version
+  version: 0.1.0.pre
+platform: ruby
+authors:
+- Brian Ustas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.6
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.12.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.12.2
+description: A library and tool for downloading Pandora.com data (likes, bookmarks,
+  stations, etc.)
+email: brianustas@gmail.com
+executables:
+- pandata
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/pandata/argv_parser.rb
+- lib/pandata/data_formatter.rb
+- lib/pandata/data_urls.rb
+- lib/pandata/downloader.rb
+- lib/pandata/parser.rb
+- lib/pandata/scraper.rb
+- lib/pandata.rb
+- bin/pandata
+homepage: https://github.com/ustasb/pandata
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.2
+signing_key: 
+specification_version: 4
+summary: A Pandora.com web scraper
+test_files: []