upcoming-api 0.1

data/Rakefile

@@ -0,0 +1,36 @@
+require 'fileutils'
+
+desc 'run all tests'
+task :test do 
+  require 'rake/runtest'
+  Rake.run_tests 'test/test*.rb'
+end
+
+desc 'clean up all non source controlled files and directories'
+task :clean do
+  FileUtils.rm_r('pkg', :force => true)
+end
+
+require 'rubygems' 
+Gem::manage_gems 
+require 'rake/gempackagetask' 
+
+spec = Gem::Specification.new do |s| 
+  s.name = "upcoming-api" 
+  s.version = "0.1" 
+  s.author = "Larry Myers" 
+  s.email = "larry@larrymyers.com" 
+  s.homepage = "http://rubyforge.org/projects/upcoming-api/" 
+  s.platform = Gem::Platform::RUBY 
+  s.summary = "A ruby library for using the Upcoming.org REST API." 
+  s.files = FileList["{tests,lib}/**/*","Rakefile","README"].to_a 
+  s.require_path = "lib" 
+  s.autorequire = "event" 
+  s.test_files = FileList["test/test*.rb"].to_a 
+  s.has_rdoc = true 
+  s.extra_rdoc_files = ["README"]  
+end 
+
+Rake::GemPackageTask.new(spec) do |pkg| 
+  pkg.need_tar = true 
+end

data/lib/upcoming.rb

@@ -0,0 +1,8 @@
+require 'upcoming/auth'
+require 'upcoming/category'
+require 'upcoming/country'
+require 'upcoming/event'
+require 'upcoming/metro'
+require 'upcoming/request'
+require 'upcoming/state'
+require 'upcoming/venue'

data/lib/upcoming/auth.rb

@@ -0,0 +1,47 @@
+require 'rexml/document'
+include REXML
+
+module Upcoming
+  class Auth
+    API_KEY = 'change-me'
+    FROB = 'change-me'
+    
+    attr_reader :token, :user_id, :user_name, :name
+    
+    def initialize
+      @token = nil
+      @user_id = nil
+      @user_name = nil
+      @name = nil
+    end
+    
+    def get_token
+      req = Upcoming::Request.new
+      resp = req.send({:method => 'auth.getToken', :frob => Upcoming::Auth::FROB})
+      
+      doc = Document.new(resp.body)
+      el = XPath.first(doc, '//token')
+      
+      @token = el.attribute('token').value
+      @user_id = el.attribute('user_id').value
+      @user_name = el.attribute('user_username').value
+      @name = el.attribute('user_name').value
+      
+      return true
+    end
+    
+    def valid_token?
+      req = Upcoming::Request.new
+      resp = req.send({:method => 'auth.checkToken', :token => @token})
+      
+      doc = Document.new(resp.body)
+      el = XPath.first(doc, '//token')
+      
+      if el.nil?
+        return false
+      end
+      
+      return true
+    end
+  end
+end

data/lib/upcoming/category.rb

@@ -0,0 +1,34 @@
+require 'rexml/document'
+require 'upcoming/request'
+include REXML
+
+module Upcoming 
+  class Category
+    attr_reader :id, :name, :description
+    
+    def initialize(id, name, description)
+      @id = id
+      @name = name
+      @description = description
+    end
+    
+    def self.info(category_id)
+      # TODO synthetic method, we'll have to call list and search it for a single id
+    end
+    
+    def self.list
+      categories = []
+      
+      req = Upcoming::Request.new
+      resp = req.send({:method => 'category.getList'})
+      
+      doc = Document.new(resp.body)
+      XPath.each(doc, '//category') do |el|
+        categories << Category.new(el.attribute('id').value,
+            el.attribute('name').value, el.attribute('description').value)
+      end
+      
+      categories
+    end
+  end
+end

data/lib/upcoming/country.rb

@@ -0,0 +1,53 @@
+require 'rexml/document'
+require 'upcoming/request'
+include REXML
+
+module Upcoming
+  class Country
+    attr_reader :id, :name, :code
+    
+    def initialize(id, name, code)
+      @id = id
+      @name = name
+      @code = code
+    end
+    
+    def self.get_info(country_id)
+      req = Upcoming::Request.new
+      resp = req.send({:method => 'country.getInfo', :country_id => country_id.to_s})
+      
+      doc = Document.new(resp.body)
+      el = XPath.first(doc, '//country')
+      
+      Country.new(el.attribute('id').value, el.attribute('name').value, el.attribute('code').value)
+    end
+    
+    def self.get_infos(country_id_list)
+      req = Upcoming::Request.new
+      resp = req.send({:method => 'country.getInfo', :country_id => country_id_list.join(',')})
+      
+      countries = []
+      
+      doc = Document.new(resp.body)
+      XPath.each(doc, '//country') do |c|
+        countries << Country.new(c.attribute('id').value, c.attribute('name').value, c.attribute('code').value)
+      end
+      
+      countries
+    end
+    
+    def self.get_all_infos
+      req = Upcoming::Request.new
+      resp = req.send({:method => 'metro.getCountryList'})
+      
+      countries = []
+      
+      doc = Document.new(resp.body)
+      XPath.each(doc, '//country') do |c|
+        countries << Country.new(c.attribute('id').value, c.attribute('name').value, c.attribute('code').value)
+      end
+      
+      countries
+    end
+  end
+end

data/lib/upcoming/event.rb

@@ -0,0 +1,103 @@
+require 'rexml/document'
+require 'upcoming/request'
+require 'upcoming/venue'
+
+module Upcoming
+  class Event
+    
+    attr_reader :id, :name, :description, :start_date, :end_date,
+        :start_time, :end_time, :date_posted, :personal, :self_promotion,
+        :lat, :lng, :gc_precision, :gc_ambiguous
+    
+    def initialize(attrs_hash)
+      @id             = attrs_hash[:id]
+      @name           = attrs_hash[:name]
+      @description    = attrs_hash[:description]
+      @start_date     = attrs_hash[:start_date]
+      @end_date       = attrs_hash[:end_date]
+      @start_time     = attrs_hash[:start_time]
+      @end_time       = attrs_hash[:end_time]
+      @date_posted    = attrs_hash[:date_posted]
+      @personal       = attrs_hash[:personal]
+      @self_promotion = attrs_hash[:self_promotion]
+      @lat            = attrs_hash[:lat]
+      @lng            = attrs_hash[:lng]
+      @gc_precision   = attrs_hash[:gc_precision]
+      @gc_ambiguous   = attrs_hash[:gc_ambiguous]
+      @user_id        = attrs_hash[:user_id]
+      @category_id    = attrs_hash[:category_id]
+      @venue_id       = attrs_hash[:venue_id]
+      @metro_id       = attrs_hash[:metro_id]
+      @state_id       = attrs_hash[:state_id]
+      @country_id     = attrs_hash[:country_id]
+    end
+    
+    def user
+      # TODO get user info about event
+    end
+    
+    def category
+      # TODO populate me intelligently
+    end
+    
+    def venue
+      Upcoming::Venue.info(@venue_id)
+    end
+    
+    def metro
+      # TODO get metro info for event
+    end
+    
+    def state
+      # TODO get state info for event
+    end
+    
+    def country
+      # TODO get country info for event
+    end
+    
+    def self.search(params)
+      params[:method] = 'event.search' if params[:method].nil?
+      
+      req = Upcoming::Request.new
+      resp = req.send(params)
+      
+      events = []
+      doc = Document.new(resp.body)
+      
+      XPath.each(doc, '//event') { |el| events << Event.create_from_node(el) }
+      
+      events
+    end
+    
+    def self.valid_params?(params)
+    end
+    
+    def self.create_from_node(node)
+      attrs = {}
+      
+      attrs[:id] = node.attribute('id').value
+      attrs[:name] = node.attribute('name').value
+      attrs[:description] = node.attribute('description').value
+      attrs[:start_date] = node.attribute('start_date').value
+      attrs[:end_date] = node.attribute('end_date').value
+      attrs[:start_time] = node.attribute('start_time').value
+      attrs[:end_time] = node.attribute('end_time').value
+      attrs[:date_posted] = node.attribute('date_posted').value
+      attrs[:personal] = node.attribute('personal').value
+      attrs[:self_promotion] = node.attribute('selfpromotion').value
+      attrs[:lat] = node.attribute('latitude').value
+      attrs[:lng] = node.attribute('longitude').value
+      attrs[:gc_precision] = node.attribute('geocoding_precision').value
+      attrs[:gc_ambiguous] = node.attribute('geocoding_ambiguous').value
+      attrs[:user_id] = node.attribute('user_id').value
+      attrs[:category_id] = node.attribute('category_id').value
+      attrs[:venue_id] = node.attribute('venue_id').value
+      attrs[:metro_id] = node.attribute('metro_id').value
+      attrs[:state_id] = node.attribute('venue_state_id').value
+      attrs[:country_id] = node.attribute('venue_country_id').value
+      
+      Event.new(attrs)
+    end
+  end
+end

data/lib/upcoming/metro.rb

@@ -0,0 +1,67 @@
+require 'rexml/document'
+require 'upcoming/request'
+require 'upcoming/state'
+require 'upcoming/country'
+include REXML
+
+module Upcoming
+  class Metro
+    attr_reader :id, :name, :code, :url, :state, :country
+    
+    def initialize(id, name, code, url, state, country)
+      @id = id
+      @name = name
+      @code = code
+      @url = url
+      @state = state
+      @country = country
+    end
+    
+    def self.search(text, state_id=nil, country_id=nil)
+      metros = []
+      
+      req = Upcoming::Request.new
+      resp = req.send({:method => 'metro.search', :search_text => text, 
+                       :state_id => state_id, :country_id => country_id})
+      
+      doc = Document.new(resp.body)
+      
+      XPath.each(doc, '//metro') do |m|
+        state = State.new(m.attribute('state_id').value, m.attribute('state_name').value,
+            m.attribute('state_code').value, m.attribute('country_id').value)
+            
+        country = Country.new(m.attribute('country_id').value, m.attribute('country_name').value,
+            m.attribute('country_code').value)
+        
+        metros << Metro.new(m.attribute('id').value, m.attribute('name').value,
+            m.attribute('code').value, m.attribute('url').value, state, country)
+      end
+      
+      metros
+    end
+    
+    def self.get_info(metro_id)
+      # TODO implement me
+    end
+    
+    def self.get_infos(metro_id_list)
+      # TODO implement me
+    end
+    
+    def self.get_by_lat_lon(lat,lon)
+      # TODO implement me
+    end
+    
+    def self.list_by_state(state_id)
+      # TODO implement me
+    end
+    
+    def self.states(country_id)
+      Upcoming::State.get_all_infos(country_id)
+    end
+    
+    def self.countries
+      Upcoming::Country.get_all_infos
+    end
+  end
+end

data/lib/upcoming/request.rb

@@ -0,0 +1,33 @@
+require 'net/http'
+require 'uri'
+require 'upcoming/auth'
+
+module Upcoming
+  class Request
+    URL = 'http://upcoming.yahooapis.com/services/rest/?'
+    
+    def send(params)
+      url = get_url(params)
+      
+      resp = nil
+      
+      begin
+        resp = Net::HTTP.get_response(URI.parse(url))
+      rescue
+        puts 'Uh oh.'
+      end
+      
+      resp
+    end
+    
+    def get_url(params)
+      url = URL + 'api_key=' + Auth::API_KEY
+      
+      params.each do |k,v|
+        url << "&#{k.to_s}=#{URI.encode(v.to_s)}"
+      end
+      
+      url
+    end
+  end
+end

data/lib/upcoming/state.rb

@@ -0,0 +1,57 @@
+require 'rexml/document'
+require 'upcoming/request'
+include REXML
+
+module Upcoming
+  class State
+    attr_reader :id, :name, :code, :country_id
+    
+    def initialize(id, name, code, country_id)
+      @id = id
+      @name = name
+      @code = code
+      @country_id = country_id
+    end
+    
+    def self.get_info(state_id)
+      req = Upcoming::Request.new
+      resp = req.send({:method => 'state.getInfo', :state_id => state_id.to_s})
+      
+      doc = Document.new(resp.body)
+      el = XPath.first(doc, '//state')
+      
+      State.new(el.attribute('id').value, el.attribute('name').value, 
+          el.attribute('code').value, el.attribute('country_id').value)
+    end
+    
+    def self.get_infos(state_id_list)
+      req = Upcoming::Request.new
+      resp = req.send({:method => 'state.getInfo', :state_id => state_id_list.join(',')})
+      
+      states = []
+      
+      doc = Document.new(resp.body)
+      XPath.each(doc, '//state') do |s|
+        states << State.new(s.attribute('id').value, s.attribute('name').
+                      value, s.attribute('code').value, s.attribute('country_id').value)
+      end
+      
+      states
+    end
+    
+    def self.get_all_infos(country_id)
+      states = []
+      
+      req = Upcoming::Request.new
+      resp = req.send({:method => 'metro.getStateList', :country_id => country_id.to_s})
+      
+      doc = Document.new(resp.body)
+      XPath.each(doc, '//state') do |s|
+        states << State.new(s.attribute('id').value, s.attribute('name').
+                      value, s.attribute('code').value, country_id.to_s)
+      end
+      
+      states
+    end
+  end
+end

data/lib/upcoming/venue.rb

@@ -0,0 +1,71 @@
+require 'rexml/document'
+require 'upcoming/request'
+include REXML
+
+module Upcoming
+  class Venue
+    attr_reader :id, :name, :city, :url, :user_id, :lat, :lng, :gc_precision
+    
+    def initialize(id, name, city, url, user_id, visibility, lat, lng, gc_precision)
+      @id = id
+      @name = name
+      @city = city
+      @url = url
+      @user_id = user_id
+      @visibility = visibility
+      @lat = lat
+      @lng = lng
+      @gc_precision = gc_precision
+    end
+    
+    def private?
+      return false if @visibility.nil? || @visibility == 0
+      
+      return true
+    end
+    
+    def self.search(params)
+      # TODO implement venue search
+    end
+    
+    def self.info(venue_id, token=nil)
+      params = {:method => 'venue.getInfo', :venue_id => venue_id}
+      params[:token] = token unless token.nil?
+      
+      req = Upcoming::Request.new
+      resp = req.send(params)
+      
+      doc = Document.new(resp.body)
+      el = XPath.first(doc, '//venue')
+      
+      Venue.new(
+        el.attribute('id').value,
+        el.attribute('name').value,
+        el.attribute('city').value,
+        el.attribute('url').value,
+        el.attribute('user_id').value,
+        el.attribute('private').value,
+        el.attribute('latitude').value,
+        el.attribute('longitude').value,
+        el.attribute('geocoding_precision').value
+      )
+    end
+    
+    def self.list(metro_id, token=nil)
+      params = {:method => 'venue.getList', :metro_id => metro_id}
+      params[:token] = token unless token.nil?
+      
+      req = Upcoming::Request.new
+      resp = req.send(params)
+      
+      venues = []
+      
+      doc = Document.new(resp.body)
+      XPath.each(doc, '//venue') do |v|
+        # TODO parse my elements, yo!
+      end
+      
+      venues
+    end
+  end
+end

data/test/test_auth.rb

@@ -0,0 +1,10 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib") 
+
+require 'upcoming/auth'
+require 'test/unit'
+
+class TestAuth < Test::Unit::TestCase
+  def test_api_key
+    assert_not_equal('', Upcoming::Auth::API_KEY)
+  end
+end

data/test/test_category.rb

@@ -0,0 +1,16 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib") 
+
+require 'upcoming/category'
+require 'test/unit'
+
+class TestCategory < Test::Unit::TestCase
+  def test_get_category_list
+    cats = Upcoming::Category.list
+    
+    assert_not_nil(cats)
+    assert_not_equal(0, cats.size)
+    assert_match(/^\d+$/, cats[0].id)
+    assert_instance_of(String, cats[0].name)
+    assert_instance_of(String, cats[0].description)
+  end
+end

data/test/test_country.rb

@@ -0,0 +1,26 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib") 
+
+require 'upcoming/country'
+require 'test/unit'
+
+class TestCountry < Test::Unit::TestCase
+  def test_get_info
+    c = Upcoming::Country.get_info(1)
+    
+    assert_equal('1', c.id)
+    assert_equal('United States', c.name)
+    assert_equal('us', c.code)
+  end
+  
+  def test_get_infos
+    countries = Upcoming::Country.get_infos([1,2,3])
+    
+    assert_equal(3, countries.size)
+  end
+  
+  def test_get_all_infos
+    countries = Upcoming::Country.get_all_infos
+    
+    assert_not_equal(0, countries.size)
+  end
+end

data/test/test_event.rb

@@ -0,0 +1,9 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib") 
+
+require 'upcoming/event'
+require 'test/unit'
+
+class TestEvent < Test::Unit::TestCase
+  def test_search
+  end
+end

data/test/test_metro.rb

@@ -0,0 +1,20 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib") 
+
+require 'upcoming/metro'
+require 'test/unit'
+
+class TestMetro < Test::Unit::TestCase
+  def test_get_states
+    states = Upcoming::Metro.states(1)
+    
+    assert_not_nil(states)
+    assert_not_equal(0, states.size)
+  end
+  
+  def test_get_countries    
+    countries = Upcoming::Metro.countries
+    
+    assert_not_nil(countries)
+    assert_not_equal(0, countries)
+  end
+end

data/test/test_request.rb

@@ -0,0 +1,28 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib") 
+
+require 'upcoming/request'
+require 'test/unit'
+
+class TestRequest < Test::Unit::TestCase
+  def test_get_url
+    expected_url = 'http://upcoming.yahooapis.com/services/rest/'
+    expected_url << '?api_key=6c43a45521&metro_id=1&method=metro.getInfo'
+    
+    params = {:method => 'metro.getInfo', :metro_id => '1'}
+    
+    req = Upcoming::Request.new
+    
+    assert_equal(expected_url, req.get_url(params))
+  end
+  
+  def test_send
+    params = {:method => 'metro.getInfo', :metro_id => '1'}
+    
+    req = Upcoming::Request.new
+    
+    resp = req.send(params)
+    
+    assert_not_nil(resp.body)
+    assert_not_equal('', resp.body)
+  end
+end

data/test/test_state.rb

@@ -0,0 +1,27 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib") 
+
+require 'upcoming/state'
+require 'test/unit'
+
+class TestState < Test::Unit::TestCase
+  def test_get_info
+    s = Upcoming::State.get_info(1)
+    
+    assert_equal('1', s.id)
+    assert_equal('Alabama', s.name)
+    assert_equal('al', s.code)
+    assert_equal('1', s.country_id)
+  end
+  
+  def test_get_infos
+    states = Upcoming::State.get_infos([1,2,3])
+    
+    assert_equal(3, states.size)
+  end
+  
+  def test_get_all_infos
+    states = Upcoming::State.get_all_infos(1)
+    
+    assert_not_equal(0, states.size)
+  end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: upcoming-api
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+date: 2007-12-24 00:00:00 -05:00
+summary: A ruby library for using the Upcoming.org REST API.
+require_paths: 
+- lib
+email: larry@larrymyers.com
+homepage: http://rubyforge.org/projects/upcoming-api/
+rubyforge_project: 
+description: 
+autorequire: event
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Larry Myers
+files: 
+- lib/upcoming
+- lib/upcoming/auth.rb
+- lib/upcoming/category.rb
+- lib/upcoming/country.rb
+- lib/upcoming/event.rb
+- lib/upcoming/metro.rb
+- lib/upcoming/request.rb
+- lib/upcoming/state.rb
+- lib/upcoming/venue.rb
+- lib/upcoming.rb
+- Rakefile
+- README
+test_files: 
+- test/test_auth.rb
+- test/test_category.rb
+- test/test_country.rb
+- test/test_event.rb
+- test/test_metro.rb
+- test/test_request.rb
+- test/test_state.rb
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+