phish_dot_net_client 0.0.1

data/.gitignore

@@ -0,0 +1,10 @@
+.DS_Store
+coverage/*
+data/*
+tmp/*
+.tags
+.tags_sorted_by_file
+.yardoc/*
+doc/*
+.ruby-gemset
+.ruby-version

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+gem 'rest-client', '~> 1.6.7'
+gem 'json', '~> 1.8.0'
+gem 'nokogiri', '~> 1.6.0'
+
+group :development do
+  gem 'rake'
+  gem 'rspec'
+  gem 'yard'
+end

data/Gemfile.lock

@@ -0,0 +1,32 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.4)
+    json (1.8.0)
+    mime-types (1.25)
+    mini_portile (0.5.1)
+    nokogiri (1.6.0)
+      mini_portile (~> 0.5.0)
+    rake (10.1.0)
+    rest-client (1.6.7)
+      mime-types (>= 1.16)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.5)
+    rspec-expectations (2.14.3)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.3)
+    yard (0.8.7.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  json (~> 1.8.0)
+  nokogiri (~> 1.6.0)
+  rake
+  rest-client (~> 1.6.7)
+  rspec
+  yard

data/README.md

@@ -0,0 +1,70 @@
+# Phish.net API Client
+
+A Phish.net API client, with support for parsing the 'setlistdata' field. Inspired by the other Ruby Phish.net API [client](http://api.phish.net/wrappers/ruby.php) written by [Stephen Blackstone](http://phish.net/user/steveb3210).
+
+[rdoc](http://rubydoc.info/github/alexebird/phish_dot_net_client/master/frames/file/README.md)
+
+
+## Install
+
+Gemfile:
+
+    gem 'phish_dot_net_client'
+
+Rubygems:
+
+    gem install phish_dot_net_client
+
+
+## Usage
+
+    # Setup frequently used parameters
+    PhishDotNetClient.apikey = 'private-api-key'
+    PhishDotNetClient.authorize 'fluffhead', 'passwurd'
+    PhishDotNetClient.clear_auth  # clears the stored apikey, username, and authkey
+
+    # Call API methods by replacing '.' with '_' in the method name
+    PhishDotNetClient.pnet_shows_setlists_latest
+
+    # The 'pnet_' prefix is optional
+    PhishDotNetClient.shows_setlists_latest
+
+    # Pass arguments to the API call with a hash
+    PhishDotNetClient.shows_setlists_get :showdate => '2013-07-31'
+    PhishDotNetClient.shows_query :month => '7', :country => 'USA', :state => 'CA'
+
+    # Arguments are not checked for validity before being passed
+    PhishDotNetClient.shows_setlists_get :fluff => 'head'  # returns {"success" => 0,"reason" => "General API Error"}
+
+    # All methods return JSON parsed into Ruby Hashes/Arrays
+    tweez = PhishDotNetClient.shows_setlists_get :showdate => '2013-07-31'
+    # => [
+    #      {
+    #        "showdate" => "2013-07-31",
+    #            "city" => "Stateline",
+    #           "state" => "NV",
+    #     "setlistdata" => #<PhishDotNetClient::Setlist ...>
+
+See [Phish.net API docs](http://api.phish.net/docu/) for available API methods.
+
+
+### setlistdata Parsing
+
+JSON objects that have a "setlistdata" will have that field parsed and replaced with
+a [Setlist](http://rubydoc.info/github/alexebird/phish_dot_net_client/master/PhishDotNetClient/Setlist) object. See rdoc for how to use the parsed setlist.
+
+
+## Known Issues
+
+- Song titles with a ',' character don't get parsed correctly due to the ',' being interpreted as a boundary between song titles. See lib/phish_dot_net_client/setlist.rb#133 for the regex and parsing code.
+
+
+
+## Testing
+
+To run specs:
+
+    bundle exec rake spec
+
+Pull requests are welcome!
+

data/Rakefile

@@ -0,0 +1,55 @@
+require 'rspec/core/rake_task'
+
+
+desc "Parse the documentation from Phish.net to get the current method calls"
+task :parse_method_docs do
+  # require 'nokogiri'
+  require 'open-uri'
+
+  doc_url = "http://api.phish.net/docu/navigation.php"
+  methods = {}
+  longest_method_name = 0
+  doc = Nokogiri::HTML(open(doc_url))
+
+  doc.css("#static-list li.sub span").each_slice(2) do |method,scope|
+    method = method.content
+    if method.size > longest_method_name
+      longest_method_name = method.size
+    end
+    methods[method] = { :scope => scope.content }
+  end
+
+  puts "{"
+  methods.keys.sort.each_with_index do |method,i|
+    comma = (i+1) == methods.size ? "" : ","
+    puts %[  %-#{longest_method_name + 3}s => { :scope => %s }%s] %
+      ['"' + method.to_s + '"', '"' + methods[method][:scope] + '"', comma]
+  end
+  puts "}"
+end
+
+
+desc "Default: run specs. Set COVERAGE=true before any spec-related task to generate code coverage."
+task :default => :spec
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = "./spec/**/*_spec.rb"
+  # t.verbose = false
+end
+
+desc "Run specs in spec/units"
+RSpec::Core::RakeTask.new('spec:units') do |t|
+  t.pattern = "./spec/units/**/*_spec.rb"
+end
+
+desc "Run specs in spec/integration"
+RSpec::Core::RakeTask.new('spec:integration') do |t|
+  t.pattern = "./spec/integration/**/*_spec.rb"
+end
+
+desc "Generate documentation"
+task :doc do
+  require 'yard'
+  sh "yard"
+end

data/lib/phish_dot_net_client.rb

@@ -0,0 +1,142 @@
+# encoding: utf-8
+
+require 'restclient'
+require 'json'
+require 'nokogiri'
+
+require 'phish_dot_net_client/set'
+require 'phish_dot_net_client/setlist'
+require 'phish_dot_net_client/song'
+require 'phish_dot_net_client/song_transition'
+require 'phish_dot_net_client/version'
+
+# @todo write doc
+module PhishDotNetClient
+  extend self
+
+  # The possible API methods. Generated from +rake parse_method_docs+.
+  # API_METHODS =
+  #   {
+  #     "pnet.api.authkey.get"        => { :scope => "protected" },
+  #     "pnet.api.authorize"          => { :scope => "protected" },
+  #     "pnet.api.authorized.check"   => { :scope => "protected" },
+  #     "pnet.api.isAuthorized"       => { :scope => "protected" },
+  #     "pnet.artists.get"            => { :scope => "public" },
+  #     "pnet.blog.get"               => { :scope => "public" },
+  #     "pnet.blog.item.get"          => { :scope => "public" },
+  #     "pnet.collections.get"        => { :scope => "protected" },
+  #     "pnet.collections.query"      => { :scope => "protected" },
+  #     "pnet.forum.canpost"          => { :scope => "protected" },
+  #     "pnet.forum.get"              => { :scope => "public" },
+  #     "pnet.forum.thread.get"       => { :scope => "protected" },
+  #     "pnet.forum.thread.new"       => { :scope => "protected" },
+  #     "pnet.forum.thread.respond"   => { :scope => "protected" },
+  #     "pnet.news.comments.get"      => { :scope => "public" },
+  #     "pnet.news.get"               => { :scope => "public" },
+  #     "pnet.reviews.query"          => { :scope => "protected" },
+  #     "pnet.reviews.recent"         => { :scope => "public" },
+  #     "pnet.shows.links.get"        => { :scope => "protected" },
+  #     "pnet.shows.query"            => { :scope => "protected" },
+  #     "pnet.shows.setlists.get"     => { :scope => "protected" },
+  #     "pnet.shows.setlists.latest"  => { :scope => "public" },
+  #     "pnet.shows.setlists.random"  => { :scope => "public" },
+  #     "pnet.shows.setlists.recent"  => { :scope => "public" },
+  #     "pnet.shows.setlists.tiph"    => { :scope => "public" },
+  #     "pnet.shows.upcoming"         => { :scope => "public" },
+  #     "pnet.user.get"               => { :scope => "protected" },
+  #     "pnet.user.myshows.add"       => { :scope => "protected" },
+  #     "pnet.user.myshows.get"       => { :scope => "protected" },
+  #     "pnet.user.myshows.remove"    => { :scope => "protected" },
+  #     "pnet.user.register"          => { :scope => "protected" },
+  #     "pnet.user.shows.rate"        => { :scope => "protected" },
+  #     "pnet.user.uid.get"           => { :scope => "protected" },
+  #     "pnet.user.username.check"    => { :scope => "protected" }
+  #   }
+
+  # The base URL for API calls
+  BASE_URL = "https://api.phish.net/api.js"
+
+  # "https://api.phish.net/api.js?api=2.0&method=pnet.shows.query&format=json&apikey=920FF765772E442F3E22&year=2011"
+
+  @@default_params = { api: "2.0",
+                    format: "json" }
+
+  def apikey=(private_api_key)
+    @@default_params.merge!(:apikey => private_api_key)
+  end
+
+  def authorize(username=nil, passwd=nil)
+    resp = call_api_method("pnet.api.authorize", :username => username, :passwd => passwd)
+
+    if resp['success'] == 1 && resp.has_key?('authkey')
+      @@default_params.merge!(:username => username, :authkey => resp['authkey'])
+    end
+  end
+
+  def clear_auth
+    [:apikey, :username, :authkey].each { |key| @@default_params.delete(key) }
+  end
+
+  # @param api_method [String] the method to call
+  # @param params [Hash] the url parameters for the api call
+  #
+  # @return [Hash, Array] the parsed JSON of API response
+  # @api private
+  def call_api_method(api_method, params={})
+    # method_data = API_METHODS[api_method]
+    # ensure_api_key if method_data[:scope] == "protected"
+
+    params.merge!(:method => api_method)
+    response = RestClient.get BASE_URL, { :params => @@default_params.merge(params) }
+
+    if response.code < 200 || response.code > 299
+      raise "non 2xx reponse: status=#{response.code}"
+    end
+
+    parsed = JSON.parse(response)
+
+    if parsed.is_a?(Array)
+      parsed.each do |obj|
+        obj["setlistdata"] = Setlist.new(obj["setlistdata"]) if obj.has_key?("setlistdata")
+      end
+    elsif parsed.is_a?(Hash)
+      parsed["setlistdata"] = Setlist.new(parsed["setlistdata"]) if parsed.has_key?("setlistdata")
+    end
+
+    return parsed
+  end
+
+  # @api private
+  def method_missing(name, *args)
+    api_method = get_api_method(name)
+
+    if api_method
+      call_api_method(api_method, *args)
+    else
+      super(name, *args)
+    end
+  end
+
+  # private
+
+  # @api private
+  def get_api_method(rb_method_name)
+    api_method_name = rb_method_name.to_s.gsub("_", ".")
+
+    unless api_method_name.match(/\Apnet\./)
+      api_method_name = 'pnet.' + api_method_name
+    end
+
+    return api_method_name
+
+    # if API_METHODS.has_key?(api_method_name)
+    #   return api_method_name
+    # else
+    #   return nil
+    # end
+  end
+
+  # def ensure_api_key
+  #   raise "api key is required" if @@default_params[:apikey].nil?
+  # end
+end

data/lib/phish_dot_net_client/set.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+# @api private
+module PhishDotNetClient
+  class Set
+
+    attr_reader :position
+    attr_reader :name
+    attr_reader :songs
+
+    def initialize(attrs={})
+      @songs = []
+      @position = attrs[:position]
+      @name = attrs[:name]
+    end
+  end
+end

data/lib/phish_dot_net_client/setlist.rb

@@ -0,0 +1,182 @@
+# encoding: utf-8
+
+# @api private
+module PhishDotNetClient
+  class Setlist
+
+    attr_reader :sets
+    attr_reader :footnotes
+
+    def initialize(setlistdata)
+      @sets, @footnotes = self.class.parse_setlistdata(setlistdata)
+    end
+
+    def songs
+      return @sets.map(&:songs).reduce([]){|memo,songs| memo += songs }
+    end
+
+    # @api private
+    def self.parse_setlistdata(setlistdata)
+      doc = Nokogiri::HTML(setlistdata)
+
+      footnotes = {}
+      footnotes_text = doc.css('.pnetfootnotes').first
+      if footnotes_text
+        footnotes_text = footnotes_text.content.split(/(?=\[\d+\])/)
+        footnotes_text.each do |note|
+          note.sub!(/\[(?<num>\d+)\]/, '').strip!
+          num = $~[:num]
+          footnotes[num.to_i] = { text: note }
+        end
+      end
+
+      sets = []
+      all_songs = []
+      transitions_tokens = []
+      slug_instances = {}
+
+      setnodes = doc.css(".pnetset")
+      position_in_show = 1
+
+      setnodes.each_with_index do |n,set_index|
+        setname = n.css(".pnetsetlabel").first.content
+        set = Set.new(:name => setname.sub!(/:\z/, ''), :position => set_index + 1)
+        songs_doc = n.css("a")
+        songs_doc.each_with_index do |song,song_index|
+          position_in_set = song_index + 1
+          title = song.content
+          url = song.attr('href')
+          slug = URI.parse(url).path
+          slug.sub!(/\A\/song\//, '')
+
+          slug_instances[slug] ||= 0
+          slug_instances[slug] += 1
+
+          song = Song.new(:title => title,
+                          :url => url,
+                          :slug => slug,
+                          :instance => slug_instances[slug],
+                          :position_in_set => position_in_set,
+                          :position_in_show => position_in_show)
+          set.songs << song
+          all_songs << song
+          position_in_show += 1
+        end
+
+        transitions_text = n.content
+        transitions_tokens += tokenize_transitions_text(transitions_text, transitions_tokens)
+
+        sets << set
+      end
+
+      augment_songs(transitions_tokens, all_songs, footnotes)
+
+      return sets, footnotes
+    end
+
+    # @api private
+    def self.augment_songs(tokens, songs, footnotes)
+      songs = Array.new(songs)  # make a copy
+
+      get_song_by_title = lambda do |title,instance|
+        songs.each do |song|
+          if song.title == title && song.instance == instance
+            return song
+          end
+        end
+        raise "no song with that title ('#{title}')"
+      end
+
+      tokens.each_index do |i|
+        prev_i = i >= 1 ? i - 1 : nil
+        next_i = i < tokens.size - 1 ? i + 1 : nil
+
+        token = tokens[i]
+        case token[:type]
+        when :note_ref
+          prev_token = tokens[prev_i]
+          song = get_song_by_title.call(prev_token[:title], prev_token[:instance])
+          num = token[:number]
+          footnotes[num][:song] = song
+          song.footnotes << num
+        when :transition
+          prev_token = tokens[prev_i]
+          if prev_token[:type] == :note_ref
+            prev_token = tokens[prev_i-1]
+          end
+          next_token = tokens[next_i]
+          from_song = get_song_by_title.call(prev_token[:title], prev_token[:instance])
+          to_song = get_song_by_title.call(next_token[:title], next_token[:instance])
+          PhishDotNetClient::SongTransition.new(token[:transition_type], from_song, to_song)
+        end
+      end
+    end
+
+    # @api private
+    def self.tokenize_transitions_text(transitions_text, existing_tokens=[])
+      tokens = []
+
+      # Account for multiple songs with the same title in a song list
+      song_title_counts = {}
+      existing_tokens.each do |token|
+        if token[:type] == :song
+          title = token[:title]
+          song_title_counts[title] ||= 0
+          song_title_counts[title] += 1
+        end
+      end
+
+      tokens.push(/\A[a-z0-9\s]+:/i => lambda do |match|
+        return { type: :set_name, name: match.to_s.strip.sub(':', '') }
+      end)
+
+      tokens.push(/\A[äa-z0-9\-?\.!:\/'\s\(\)]+[a-z0-9\)?!']/i => lambda do |match|
+        title = match.to_s.strip
+        song_title_counts[title] ||= 0
+        song_title_counts[title] += 1
+        return { type: :song, title: title, instance: song_title_counts[title] }
+      end)
+
+      tokens.push(/\A\[(?<num>\d+)\]/ => lambda do |match|
+        return { type: :note_ref, number: match[:num].to_i }
+      end)
+
+      tokens.push(/\A,/ => lambda do |match|
+        return { type: :transition, transition_type: :no_segue }
+      end)
+
+      tokens.push(/\A>/ => lambda do |match|
+        return { type: :transition, transition_type: :segue }
+      end)
+
+      tokens.push(/\A->/ => lambda do |match|
+        return { type: :transition, transition_type: :deep_segue }
+      end)
+
+      tokens.push(/\A\s+/ => lambda do |match|
+        return nil
+      end)
+
+      parsed_set = []
+
+      until transitions_text.empty?
+        matched = false
+
+        tokens.each do |matcher|
+          token_regex, processor = matcher.keys.first, matcher.values.first
+
+          if transitions_text.slice!(token_regex)
+            matched = true
+            token = processor.call($~)
+            parsed_set.push(token) if token
+            break
+          end
+        end
+
+        raise "could not parse: '#{transitions_text}'" unless matched
+      end
+
+      return parsed_set
+    end
+  end
+end

data/lib/phish_dot_net_client/song.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+# @api private
+module PhishDotNetClient
+  class Song
+    attr_reader :title
+    attr_reader :url
+    attr_reader :slug
+    attr_reader :instance
+    attr_reader :position_in_set
+    attr_reader :position_in_show
+    attr_reader :footnotes
+    attr_accessor :pre_transition
+    attr_accessor :post_transition
+
+    def initialize(attrs={})
+      @title = attrs[:title]
+      @url = attrs[:url]
+      @slug = attrs[:slug]
+      @instance = attrs[:instance]
+      @position_in_set = attrs[:position_in_set]
+      @position_in_show = attrs[:position_in_show]
+      @footnotes = []
+    end
+
+    def to_s
+      s = StringIO.new
+
+      if pre_transition
+        s.print "#{pre_transition.from_song.title}(#{pre_transition.from_song.instance})..."
+      else
+        s.print "x..."
+      end
+
+      s.print "#{@title}(#{@instance})"
+
+      if post_transition
+        s.puts "...#{post_transition.to_song.title}(#{post_transition.to_song.instance})"
+      else
+        s.puts "...x"
+      end
+
+      s.puts
+      return s.string
+    end
+  end
+end

data/lib/phish_dot_net_client/song_transition.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+# @api private
+module PhishDotNetClient
+  class SongTransition
+
+    attr_reader :type
+    attr_reader :from_song
+    attr_reader :to_song
+
+    def initialize(type, from_song, to_song)
+      @type = type
+      @from_song = from_song
+      @to_song = to_song
+      @from_song.post_transition = @to_song.pre_transition = self
+    end
+  end
+end

data/lib/phish_dot_net_client/version.rb

@@ -0,0 +1,3 @@
+module PhishDotNetClient
+  VERSION = '0.0.1'
+end

data/phish_dot_net_client.gemspec

@@ -0,0 +1,31 @@
+# encoding: utf-8
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+require 'phish_dot_net_client/version'
+
+Gem::Specification.new do |spec|
+  spec.name        = 'phish_dot_net_client'
+  spec.version     = PhishDotNetClient::VERSION
+  spec.date        = Date.today.to_s
+  spec.licenses    = ['MIT']
+  spec.authors     = ["Alexander Bird"]
+  spec.email       = ["alexebird@gmail.com"]
+  spec.homepage    = "https://github.com/alexebird/phish_dot_net_client"
+  spec.summary     = %q{Phish.net API client with setlist parsing}
+  spec.description = %q{Calls any Phish.net API method. Supports authentication. Parses 'setlistdata' fields.}
+
+  spec.required_ruby_version     = '>= 1.9.1'
+  spec.required_rubygems_version = '>= 1.3.6'
+
+  spec.add_dependency 'rest-client', '~> 1.6.7'
+  spec.add_dependency 'json', '~> 1.8.0'
+  spec.add_dependency 'nokogiri', '~> 1.6.0'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 2.14'
+  spec.add_development_dependency 'yard', '~> 0.8'
+
+  spec.files       = `git ls-files`.split($/)
+  spec.test_files  = spec.files.grep(%r{^spec/})
+
+  spec.require_paths = ["lib"]
+end

data/spec/phish_dot_net_client/set_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe PhishDotNetClient::Set do
+  let(:set) { PhishDotNetClient::Set }
+  let(:set_instance) { set.new }
+
+  %w[position name songs].each do |attr|
+    it "has a #{attr} attribute" do
+      expect(set_instance.respond_to? attr.to_sym).to be_true
+    end
+  end
+end

data/spec/phish_dot_net_client/setlist_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+describe PhishDotNetClient::Setlist do
+  # Set 1: Runaway Jim[1], Foam, Punch You In the Eye[2] > Bathtub Gin, Cavern
+  # Set 2: Also Sprach Zarathustra -> Cavern
+  # Encore: Sleeping Monkey
+  let(:setlistdata) { "<p class='pnetset pnetset1'><span class='pnetsetlabel'>Set 1:<\/span> <a href=\"http:\/\/phish.net\/song\/runaway-jim\">Runaway Jim<\/a><sup>[1]<\/sup>,  <a href=\"http:\/\/phish.net\/song\/foam\">Foam<\/a>,  <a href=\"http:\/\/phish.net\/song\/punch-you-in-the-eye\">Punch You In the Eye<\/a><sup>[2]<\/sup> >  <a href=\"http:\/\/phish.net\/song\/bathtub-gin\">Bathtub Gin<\/a>,  <a href=\"http:\/\/phish.net\/song\/cavern\">Cavern<\/a><\/p><p class='pnetset pnetset2'><span class='pnetsetlabel'>Set 2:<\/span> <a href=\"http:\/\/phish.net\/song\/also-sprach-zarathustra\">Also Sprach Zarathustra<\/a> ->  <a href=\"http:\/\/phish.net\/song\/cavern\">Cavern<\/a> <p class='pnetset pnetsete'><span class='pnetsetlabel'>Encore:<\/span> <a href=\"http:\/\/phish.net\/song\/sleeping-monkey\">Sleeping Monkey<\/a> <p class='pnetfootnotes'>[1] O.J. reference.<br \/>[2] \"Anti-drum solo.\"<br \/><\/p>" }
+  let(:setlist) { PhishDotNetClient::Setlist }
+  let(:setlist_instance) { setlist.new(setlistdata) }
+  let(:setlist_dumb_instance) { setlist.new('') }
+
+  it "has a sets attribute" do
+    expect(setlist_dumb_instance.respond_to? :sets).to be_true
+  end
+
+  it "has a footnotes attribute" do
+    expect(setlist_dumb_instance.respond_to? :footnotes).to be_true
+  end
+
+  describe "#initialize" do
+    it "sets the sets" do
+      expect(setlist_instance.sets).to be_instance_of(Array)
+    end
+  end
+
+  describe ".parse_setlistdata" do
+    let(:parsed_setlist) { setlist.parse_setlistdata(setlistdata) }
+
+    it "returns Array(sets), Hash(footnotes)" do
+      expect(parsed_setlist).to be_instance_of(Array)
+      sets = parsed_setlist.first
+      expect(sets).to be_instance_of(Array)
+      notes = parsed_setlist.last
+      expect(notes).to eq({ 1 => { text: %[O.J. reference.], song: sets[0].songs[0] },
+                            2 => { text: %["Anti-drum solo."], song: sets[0].songs[2] } })
+
+      set1 = sets[0]
+      expect(set1).to be_instance_of(PhishDotNetClient::Set)
+      set1.songs.each do |song|
+        expect(song).to be_instance_of(PhishDotNetClient::Song)
+      end
+
+      set2 = sets[1]
+      expect(set2).to be_instance_of(PhishDotNetClient::Set)
+      set2.songs.each do |song|
+        expect(song).to be_instance_of(PhishDotNetClient::Song)
+      end
+
+      encore = sets[2]
+      expect(encore).to be_instance_of(PhishDotNetClient::Set)
+      encore.songs.each do |song|
+        expect(song).to be_instance_of(PhishDotNetClient::Song)
+      end
+    end
+  end
+
+  describe "#songs" do
+    it "returns all songs" do
+      expect(setlist_instance.songs.size).to eq(8)
+    end
+  end
+
+  describe ".augment_songs" do
+    let(:song1) { PhishDotNetClient::Song.new(:title => "Song 1", :instance => 1) }
+    let(:song2) { PhishDotNetClient::Song.new(:title => "Song 2", :instance => 1) }
+    let(:song1again) { PhishDotNetClient::Song.new(:title => "Song 1", :instance => 2) }
+    let(:transitions_tokens) { setlist.tokenize_transitions_text("Set 1: Song 1[1] > Song 2 -> Song 1") }
+    let(:footnotes) { { 1 => { text: %[O.J. reference.] },
+                        2 => { text: %["Anti-drum solo."] } } }
+
+    it "adds transitions to the songs" do
+      setlist.augment_songs(transitions_tokens, [song1, song2, song1again], footnotes)
+      expect(song1.post_transition).to be_instance_of(PhishDotNetClient::SongTransition)
+      expect(song1.post_transition).to eq(song2.pre_transition)
+      expect(song1.post_transition.type).to eq(:segue)
+    end
+
+    it "accounts for songs with the same title" do
+      setlist.augment_songs(transitions_tokens, [song1, song2, song1again], footnotes)
+      expect(song2.post_transition).to eq(song1again.pre_transition)
+      expect(song2.post_transition.type).to eq(:deep_segue)
+    end
+
+    it "adds notes to the songs" do
+      setlist.augment_songs(transitions_tokens, [song1, song2, song1again], footnotes)
+      expect(song1.footnotes).to eq([1])
+    end
+  end
+
+  describe ".tokenize_transitions_text" do
+    let(:setlist_str) { "Set 1: Runaway Jim[1] ->  Foam,  Punch You In the Eye[2] >  Bathtub Gin, Foam" }
+    let(:parsed_text) { setlist.tokenize_transitions_text(setlist_str) }
+
+    it "parses the set's text" do
+      expect(parsed_text).to eq([
+       { type: :set_name, name: "Set 1" },
+       { type: :song, title: "Runaway Jim", instance: 1 },
+       { type: :note_ref, number: 1 },
+       { type: :transition, transition_type: :deep_segue },
+       { type: :song, title: "Foam", instance: 1  },
+       { type: :transition, transition_type: :no_segue },
+       { type: :song, title: "Punch You In the Eye", instance: 1  },
+       { type: :note_ref, number: 2 },
+       { type: :transition, transition_type: :segue },
+       { type: :song, title: "Bathtub Gin", instance: 1  },
+       { type: :transition, transition_type: :no_segue },
+       { type: :song, title: "Foam", instance: 2  }
+       ])
+    end
+
+    it "raises an error for unparsable text" do
+      expect{ setlist.tokenize_transitions_text("asdf !@###") }.to raise_error
+    end
+  end
+end

data/spec/phish_dot_net_client/song_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe PhishDotNetClient::Song do
+  let(:song) { PhishDotNetClient::Song }
+  let(:song_instance) { song.new }
+
+  %w[title url slug instance position_in_set position_in_show footnotes pre_transition post_transition].each do |attr|
+    it "has a #{attr} attribute" do
+      expect(song_instance.respond_to? attr.to_sym).to be_true
+    end
+  end
+
+  describe "#initialize" do
+    it "sets the attributes" do
+      s = song.new(:title => 'title', :url => 'http://url', :slug => "slug", :instance => "inst",
+        :position_in_set => 3, :position_in_show => 5)
+      expect(s.title).to eq('title')
+      expect(s.url).to eq('http://url')
+      expect(s.slug).to eq('slug')
+      expect(s.instance).to eq('inst')
+      expect(s.position_in_set).to eq(3)
+      expect(s.position_in_show).to eq(5)
+    end
+  end
+end

data/spec/phish_dot_net_client/song_transition_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe PhishDotNetClient::SongTransition do
+  let(:from_song) { PhishDotNetClient::Song.new(:title => "Song 1") }
+  let(:to_song) { PhishDotNetClient::Song.new(:title => "Song 2") }
+  let(:song_trans) { PhishDotNetClient::SongTransition }
+  let!(:song_trans_instance) { PhishDotNetClient::SongTransition.new(:deep_segue, from_song, to_song) }
+
+  %w[type from_song to_song].each do |attr|
+    it "has a #{attr} attribute" do
+      expect(song_trans_instance.respond_to? attr.to_sym).to be_true
+    end
+  end
+
+  describe "#initialize" do
+    it "sets the attributes" do
+      expect(song_trans_instance.type).to eq(:deep_segue)
+      expect(song_trans_instance.from_song).to eq(from_song)
+      expect(song_trans_instance.to_song).to eq(to_song)
+    end
+
+    it "sets the songs transitions" do
+      expect(from_song.post_transition).to eq(song_trans_instance)
+      expect(to_song.pre_transition).to eq(song_trans_instance)
+    end
+  end
+end

data/spec/phish_dot_net_client_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe PhishDotNetClient do
+  let(:pnet) { PhishDotNetClient }
+  let(:fake_api_key) { "fake-apikey" }
+
+  def access_default_params(key)
+    return pnet.class_variable_get(:@@default_params)[key]
+  end
+
+  it "pre-sets the api version to '2.0'" do
+    expect(access_default_params(:api)).to eq('2.0')
+  end
+
+  it "pre-sets the response format to json" do
+    expect(access_default_params(:format)).to eq('json')
+  end
+
+  describe "#apikey=" do
+    it "sets the api key" do
+      pnet.apikey = fake_api_key
+      expect(access_default_params(:apikey)).to eq(fake_api_key)
+    end
+  end
+
+  describe "#authorize" do
+    it "sets the username" do
+      # pnet.authorize('uzer', 'asdfasdf')
+      # expect(access_default_params(:username)).to eq('uzer')
+    end
+  end
+
+  describe "#clear_auth" do
+    before(:each) do
+      pnet.clear_auth
+    end
+
+    it "clears the apikey" do
+      expect(access_default_params(:apikey)).to be_nil
+    end
+
+    it "clears the authkey" do
+      expect(access_default_params(:authkey)).to be_nil
+    end
+
+    it "clears the username" do
+      expect(access_default_params(:username)).to be_nil
+    end
+  end
+
+  describe "#call_api_method" do
+    # context "when the api_method is protected" do
+    #   it "raises an error if no apikey is specified" do
+    #     pnet.clear_auth
+    #     expect{ pnet.call_api_method("pnet.shows.query") }.to raise_error
+    #   end
+    # end
+
+    it "calls the api" do
+      rv = pnet.call_api_method("pnet.shows.setlists.latest")
+      expect(rv[0]["setlistdata"]).to be_instance_of(PhishDotNetClient::Setlist)
+    end
+  end
+
+  describe "#method_missing" do
+    context "when the api method is a valid" do
+      it "delegates to call_api_method" do
+        expect{ pnet.method_missing :"pnet_shows_setlists_latest" }.not_to raise_error
+      end
+    end
+
+    # context "when the method name is not a valid api method" do
+    #   it "passes the method_missing call on to super" do
+    #     expect{ pnet.method_missing :"asdf_jkl" }.to raise_error(NoMethodError)
+    #   end
+    # end
+  end
+
+  describe "#get_api_method" do
+    # it "returns nil when the api_method doesn't exist" do
+    #   expect(pnet.get_api_method('doesnt_exist')).to be_nil
+    # end
+
+    it "returns the api method" do
+      expect(pnet.get_api_method("pnet_api_authorize")).to eq("pnet.api.authorize")
+    end
+
+    it "adds the 'pnet.' prefix if it's not there" do
+      expect(pnet.get_api_method("api_authorize")).to eq("pnet.api.authorize")
+    end
+  end
+
+  # describe "#ensure_api_key" do
+  #   it "raises an error if api_key isn't set" do
+  #     expect{ pnet.ensure_api_key }.to raise_error
+  #   end
+  # end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'bundler'
+Bundler.require :development
+
+require './lib/phish_dot_net_client'
+
+RSpec.configure do |config|
+end

metadata

@@ -0,0 +1,177 @@
+--- !ruby/object:Gem::Specification 
+name: phish_dot_net_client
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Alexander Bird
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-10-09 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rest-client
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 6
+        - 7
+        version: 1.6.7
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 8
+        - 0
+        version: 1.8.0
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: nokogiri
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 6
+        - 0
+        version: 1.6.0
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 14
+        version: "2.14"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: yard
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 8
+        version: "0.8"
+  type: :development
+  version_requirements: *id006
+description: Calls any Phish.net API method. Supports authentication. Parses 'setlistdata' fields.
+email: 
+- alexebird@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- lib/phish_dot_net_client.rb
+- lib/phish_dot_net_client/set.rb
+- lib/phish_dot_net_client/setlist.rb
+- lib/phish_dot_net_client/song.rb
+- lib/phish_dot_net_client/song_transition.rb
+- lib/phish_dot_net_client/version.rb
+- phish_dot_net_client.gemspec
+- spec/phish_dot_net_client/set_spec.rb
+- spec/phish_dot_net_client/setlist_spec.rb
+- spec/phish_dot_net_client/song_spec.rb
+- spec/phish_dot_net_client/song_transition_spec.rb
+- spec/phish_dot_net_client_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: https://github.com/alexebird/phish_dot_net_client
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 9
+      - 1
+      version: 1.9.1
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7.1
+signing_key: 
+specification_version: 3
+summary: Phish.net API client with setlist parsing
+test_files: 
+- spec/phish_dot_net_client/set_spec.rb
+- spec/phish_dot_net_client/setlist_spec.rb
+- spec/phish_dot_net_client/song_spec.rb
+- spec/phish_dot_net_client/song_transition_spec.rb
+- spec/phish_dot_net_client_spec.rb
+- spec/spec_helper.rb