rMeetup 1.0

data/Manifest

@@ -0,0 +1,45 @@
+Manifest
+README.rdoc
+Rakefile
+lib/rmeetup.rb
+lib/rmeetup/collection.rb
+lib/rmeetup/fetcher.rb
+lib/rmeetup/fetcher/base.rb
+lib/rmeetup/fetcher/cities.rb
+lib/rmeetup/fetcher/comments.rb
+lib/rmeetup/fetcher/events.rb
+lib/rmeetup/fetcher/groups.rb
+lib/rmeetup/fetcher/members.rb
+lib/rmeetup/fetcher/photos.rb
+lib/rmeetup/fetcher/rsvps.rb
+lib/rmeetup/fetcher/topics.rb
+lib/rmeetup/type.rb
+lib/rmeetup/type/city.rb
+lib/rmeetup/type/comment.rb
+lib/rmeetup/type/event.rb
+lib/rmeetup/type/group.rb
+lib/rmeetup/type/member.rb
+lib/rmeetup/type/photo.rb
+lib/rmeetup/type/rsvp.rb
+lib/rmeetup/type/topic.rb
+spec/client_spec.rb
+spec/fetcher_spec.rb
+spec/fetchers/base_spec.rb
+spec/fetchers/cities_spec.rb
+spec/fetchers/comments_spec.rb
+spec/fetchers/events_spec.rb
+spec/fetchers/groups_spec.rb
+spec/fetchers/members_spec.rb
+spec/fetchers/photos_spec.rb
+spec/fetchers/rsvps_spec.rb
+spec/fetchers/topics_spec.rb
+spec/responses/cities.json
+spec/responses/comments.json
+spec/responses/error.json
+spec/responses/events.json
+spec/responses/groups.json
+spec/responses/members.json
+spec/responses/photos.json
+spec/responses/rsvps.json
+spec/responses/topics.json
+spec/spec_helper.rb

data/README.rdoc

@@ -0,0 +1,34 @@
+= rMeetup
+
+A simple Ruby gem to access the Meetup API.
+
+== Code Sample
+
+Sample code is worth a thousand words:
+
+  RMeetup::Client.api_key = "API_KEY"
+  results = RMeetup::Client.fetch(:events,{:zip => "ZIP_CODE"})
+  results.each do |result|
+    # Do something with the result
+  end
+  
+RMeetup::Client.fetch takes a data model type and set of options as arguments. Possible data models are:
+
+* :topics
+* :cities
+* :members
+* :rsvps
+* :events
+* :groups
+* :comments
+* :photos
+ 
+The options that may be passed can be found on the Meetup API documentation. Please see http://www.meetup.com/meetup_api/docs/ and look up the model that you are calling (i.e. for :events, look at the API call "GET /events" at http://www.meetup.com/meetup_api/docs/events/).
+
+== Installation
+
+
+
+== Credit
+
+Credit goes to Jared Pace for building the initial iteration of this gem. I just forked it, expanded and documented it a but.

data/Rakefile

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'rake'
+require 'echoe'
+
+Echoe.new('rMeetup','1.0') do |p|
+  p.description = "A simple Ruby gem, providing access to the Meetup API"
+  p.url         = "https://github.com/Jberlinsky/rmeetup"
+  p.author      = "Jason Berlinsky"
+  p.email       = "jason@jasonberlinsky.com"
+  p.ignore_pattern  = ["tmp/*", "script/*"]
+  p.development_dependencies  = []
+end
+
+Dir["#{File.dirname(__FILE__)}/tasks/*.rake"].sort.each { |ext| load ext }

data/lib/rmeetup/collection.rb

@@ -0,0 +1,58 @@
+module RMeetup
+  class Collection < Array
+    attr_accessor :page_size, :total_results
+    attr_writer   :current_page
+    
+    def self.build(response)
+      collection = Collection.new()
+      
+      # Setup the attributes needed for WillPaginate style paging
+      request_url = response['meta']['url']
+      request_parameters = parse_parameters_from_url(request_url)
+      collection.page_size = request_parameters['page'] ? request_parameters['page'].to_i : nil
+      collection.total_results = response['meta']['total_count'].to_i
+      collection.current_page = request_parameters['offset'] ? (request_parameters['offset'].to_i + 1) : 1
+      
+      # Load the collection with all
+      # of the results we passed in
+      response['results'].each do |result|
+        collection << result
+      end
+      
+      collection
+    end
+    
+    # = WillPaginate Helper Methods
+    #
+    # These methods are implementded so that
+    # you may pass this collection to the will_paginate
+    # view helper to render pagination links.
+    def current_page
+      @current_page
+    end
+    
+    def total_pages
+      @page_size ? (@total_results.to_f / @page_size.to_f).ceil : 1
+    end
+    
+    def previous_page
+      self.current_page == 1 ? nil : self.current_page.to_i-1
+    end
+    
+    def next_page
+      self.current_page == self.total_pages ? nil : self.current_page.to_i+1
+    end
+    
+    protected
+      def self.parse_parameters_from_url(url)
+        query = URI.parse(url).query
+        parameters = {}
+        
+        query.split("&").each do |kv|
+          kv = kv.split("=")
+          parameters[kv[0]] = kv[1]
+        end
+        parameters
+      end
+  end
+end

data/lib/rmeetup/fetcher/base.rb

@@ -0,0 +1,84 @@
+module RMeetup
+  module Fetcher
+    class ApiError < StandardError
+      def initialize(error_message, request_url)
+        super "Meetup API Error: #{error_message} - API URL: #{request_url}"
+      end
+    end
+
+    class NoResponseError < StandardError
+      def initialize
+        super "No Response was returned from the Meetup API."
+      end
+    end
+    
+    # == RMeetup::Fetcher::Base
+    # 
+    # Base fetcher class that other fetchers 
+    # will inherit from.
+    class Base
+      def initialize
+        @type = nil
+      end
+      
+      # Fetch and parse a response
+      # based on a set of options.
+      # Override this method to ensure
+      # neccessary options are passed
+      # for the request.
+      def fetch(options = {})
+        url = build_url(options)
+        
+        json = get_response(url)
+        data = JSON.parse(json)
+        
+        # Check to see if the api returned an error
+        raise ApiError.new(data['details'],url) if data.has_key?('problem')
+        
+        collection = RMeetup::Collection.build(data)
+        
+        # Format each result in the collection and return it
+        collection.map!{|result| format_result(result)}
+      end
+      
+      protected
+        # OVERRIDE this method to format a result section
+        # as per Result type.
+        # Takes a result in a collection and
+        # formats it to be put back into the collection.
+        def format_result(result)
+          result
+        end
+      
+        def build_url(options)
+          options = encode_options(options)
+          
+          base_url + params_for(options)
+        end
+      
+        def base_url
+          "http://api.meetup.com/#{@type}.json/"
+        end
+        
+        # Create a query string from an options hash
+        def params_for(options)
+          params = []
+          options.each do |key, value|
+            params << "#{key}=#{value}"
+          end
+          "?#{params.join("&")}"
+        end
+        
+        # Encode a hash of options to be used as request parameters
+        def encode_options(options)
+          options.each do |key,value|
+            options[key] = URI.encode(value.to_s)
+          end
+        end
+        
+        def get_response(url)
+          Net::HTTP.get_response(URI.parse(url)).body || raise(NoResponseError.new)
+        end
+    end
+  end
+end

data/lib/rmeetup/fetcher/cities.rb

@@ -0,0 +1,14 @@
+module RMeetup
+  module Fetcher
+    class Cities < Base
+      def initialize
+        @type = :cities
+      end
+      
+      # Turn the result hash into a City Class
+      def format_result(result)
+        RMeetup::Type::City.new(result)
+      end
+    end
+  end
+end

data/lib/rmeetup/fetcher/comments.rb

@@ -0,0 +1,14 @@
+module RMeetup
+  module Fetcher
+    class Comments < Base
+      def initialize
+        @type = :comments
+      end
+      
+      # Turn the result hash into a Comment Class
+      def format_result(result)
+        RMeetup::Type::Comment.new(result)
+      end
+    end
+  end
+end

data/lib/rmeetup/fetcher/events.rb

@@ -0,0 +1,14 @@
+module RMeetup
+  module Fetcher
+    class Events < Base
+      def initialize
+        @type = :events
+      end
+      
+      # Turn the result hash into a Event Class
+      def format_result(result)
+        RMeetup::Type::Event.new(result)
+      end
+    end
+  end
+end

data/lib/rmeetup/fetcher/groups.rb

@@ -0,0 +1,14 @@
+module RMeetup
+  module Fetcher
+    class Groups < Base
+      def initialize
+        @type = :groups
+      end
+      
+      # Turn the result hash into a Group Class
+      def format_result(result)
+        RMeetup::Type::Group.new(result)
+      end
+    end
+  end
+end

data/lib/rmeetup/fetcher/members.rb

@@ -0,0 +1,14 @@
+module RMeetup
+  module Fetcher
+    class Members < Base
+      def initialize
+        @type = :members
+      end
+      
+      # Turn the result hash into a Member Class
+      def format_result(result)
+        RMeetup::Type::Member.new(result)
+      end
+    end
+  end
+end

data/lib/rmeetup/fetcher/photos.rb

@@ -0,0 +1,14 @@
+module RMeetup
+  module Fetcher
+    class Photos < Base
+      def initialize
+        @type = :photos
+      end
+      
+      # Turn the result hash into a Photo Class
+      def format_result(result)
+        RMeetup::Type::Photo.new(result)
+      end
+    end
+  end
+end

data/lib/rmeetup/fetcher/rsvps.rb

@@ -0,0 +1,14 @@
+module RMeetup
+  module Fetcher
+    class Rsvps < Base
+      def initialize
+        @type = :rsvps
+      end
+      
+      # Turn the result hash into a Rsvp Class
+      def format_result(result)
+        RMeetup::Type::Rsvp.new(result)
+      end
+    end
+  end
+end

data/lib/rmeetup/fetcher/topics.rb

@@ -0,0 +1,14 @@
+module RMeetup
+  module Fetcher
+    class Topics < Base
+      def initialize
+        @type = :topics
+      end
+      
+      # Turn the result hash into a Topic Class
+      def format_result(result)
+        RMeetup::Type::Topic.new(result)
+      end
+    end
+  end
+end

data/lib/rmeetup/fetcher.rb

@@ -0,0 +1,38 @@
+require "rmeetup/fetcher/base"
+require "rmeetup/fetcher/topics"
+require "rmeetup/fetcher/cities"
+require "rmeetup/fetcher/members"
+require "rmeetup/fetcher/rsvps"
+require "rmeetup/fetcher/events"
+require "rmeetup/fetcher/groups"
+require "rmeetup/fetcher/comments"
+require "rmeetup/fetcher/photos"
+
+module RMeetup
+  module Fetcher
+    
+    class << self
+      # Return a fetcher for given type
+      def for(type)
+        return  case type.to_sym
+                when :topics
+                  Topics.new
+                when :cities      
+                  Cities.new
+                when :members     
+                  Members.new
+                when :rsvps       
+                  Rsvps.new
+                when :events      
+                  Events.new
+                when :groups      
+                  Groups.new
+                when :comments    
+                  Comments.new
+                when :photos
+                  Photos.new
+                end
+      end 
+    end
+  end
+end

data/lib/rmeetup/type/city.rb

@@ -0,0 +1,39 @@
+module RMeetup
+  module Type
+    
+    # == RMeetup::Type::City
+    #
+    # Data wraper for a City fethcing response
+    # Used to access result attributes as well
+    # as progammatically fetch relative data types
+    # based on this city.
+    
+    # Edited by Jason Berlinsky on 1/20/11 to allow for arbitrary data access
+    # See http://www.meetup.com/meetup_api/docs/cities/ for available fields
+    
+    class City
+      
+      attr_accessor :city
+      
+      def initialize(city = {})
+        self.city = city
+      end
+      
+      def method_missing(id, *args)
+        return self.city[id.id2name]
+      end
+      
+      # Special accessors that need typecasting or other parsing
+      
+      def lat
+        return self.city['lat'].to_f
+      end
+      def lon
+        return self.city['lon'].to_f
+      end
+      def members
+        return self.city['members'].to_i
+      end
+    end
+  end
+end

data/lib/rmeetup/type/comment.rb

@@ -0,0 +1,42 @@
+module RMeetup
+  module Type
+    
+    # == RMeetup::Type::Comment
+    #
+    # Data wraper for a Comment fethcing response
+    # Used to access result attributes as well
+    # as progammatically fetch relative data types
+    # based on this comment.
+    
+    # Edited by Jason Berlinsky on 1/20/11 to allow for arbitrary data access
+    # See http://www.meetup.com/meetup_api/docs/ew/comment/ for available fields
+    
+    class Comment
+      
+      attr_accessor :comment
+      
+      def initialize(comment = {})
+        self.comment = comment
+      end
+      
+      def method_missing(id, *args)
+        return self.comment[id.id2name]
+      end
+      
+      # Special accessors that need typecasting or other parsing
+      
+      def rating
+        return self.comment['rating'].to_i
+      end
+      def created
+        return DateTime.parse(self.comment['created'])
+      end
+      def lat
+        return self.comment['lat'].to_f
+      end
+      def lon
+        return self.comment['lon'].to_f
+      end
+    end
+  end
+end

data/lib/rmeetup/type/event.rb

@@ -0,0 +1,47 @@
+module RMeetup
+  module Type
+    
+    # == RMeetup::Type::Event
+    #
+    # Data wraper for a Event fethcing response
+    # Used to access result attributes as well
+    # as progammatically fetch relative data types
+    # based on this event.
+    
+    # Edited by Jason Berlinsky on 1/20/11 to allow for arbitrary data access
+    # See http://www.meetup.com/meetup_api/docs/events/ for available fields
+    
+    class Event
+      
+      attr_accessor :event
+      
+      def initialize(event = {})
+        self.event = event
+      end
+      
+      def method_missing(id, *args)
+        return self.event[id.id2name]
+      end
+      
+      # Special accessors that need typecasting or other parsing
+      def id
+        self.event['id'].to_i
+      end
+      def lat
+        self.event['lat'].to_f
+      end
+      def lon
+        self.event['lon'].to_f
+      end
+      def rsvpcount
+        self.event['rsvpcount'].to_i
+      end
+      def updated
+        DateTime.parse(self.event['updated'])
+      end
+      def time
+        DateTime.parse(self.event['time'])
+      end
+    end
+  end
+end

data/lib/rmeetup/type/group.rb

@@ -0,0 +1,47 @@
+module RMeetup
+  module Type
+    
+    # == RMeetup::Type::Group
+    #
+    # Data wraper for a Group fethcing response
+    # Used to access result attributes as well
+    # as progammatically fetch relative data types
+    # based on this group.
+    
+    # Edited by Jason Berlinsky on 1/20/11 to allow for arbitrary data access
+    # See http://www.meetup.com/meetup_api/docs/groups/ for available fields
+    
+    class Group
+      attr_accessor :group
+      
+      def initialize(group = {})
+        self.group = group
+      end
+      
+      def method_missing(id, *args)
+        return self.group[id.id2name]
+      end
+      
+      # Special accessors that need typecasting or other parsing
+      
+      def id
+        return self.group['id'].to_i
+      end
+      def updated
+        return DateTime.parse(self.group['updated'])
+      end
+      def created
+        return DateTime.parse(self.group['created'])
+      end
+      def lat
+        return self.group['lat'].to_f
+      end
+      def lon
+        return self.group['lon'].to_f
+      end
+      def daysleft
+        return self.group['daysleft'].to_i
+      end
+    end
+  end
+end

data/lib/rmeetup/type/member.rb

@@ -0,0 +1,38 @@
+module RMeetup
+  module Type
+    
+    # == RMeetup::Type::Member
+    #
+    # Data wraper for a Member fethcing response
+    # Used to access result attributes as well
+    # as progammatically fetch relative data types
+    # based on this member.
+    
+    # Edited by Jason Berlinsky on 1/20/11 to allow for arbitrary data access
+    # See http://www.meetup.com/meetup_api/docs/members/ for available fields
+    
+    class Member
+      attr_accessor :member
+      
+      def initialize(member = {})
+        self.member = member
+      end
+      
+      def method_missing(id, *args)
+        return self.member[id.id2name]
+      end
+      
+      # Special accessors that need typecasting or other parsing
+      
+      def id
+        return self.member['id'].to_i
+      end
+      def lat
+        return self.member['lat'].to_f
+      end
+      def lon
+        return self.member['lon'].to_f
+      end
+    end
+  end
+end

data/lib/rmeetup/type/photo.rb

@@ -0,0 +1,32 @@
+module RMeetup
+  module Type
+    
+    # == RMeetup::Type::Photo
+    #
+    # Data wraper for a Photo fethcing response
+    # Used to access result attributes as well
+    # as progammatically fetch relative data types
+    # based on this photo.
+    
+    # Edited by Jason Berlinsky on 1/20/11 to allow for arbitrary data access
+    # See http://www.meetup.com/meetup_api/docs/photos/ for available fields
+    
+    class Photo
+      attr_accessor :photo
+      
+      def initialize(photo = {})
+        self.photo = photo
+      end
+      
+      def method_missing(id, *args)
+        return self.photo[id.id2name]
+      end
+      
+      # Special accessors that need typecasting or other parsing
+      
+      def created
+        return DateTime.parse(self.photo['created'])
+      end
+    end
+  end
+end

data/lib/rmeetup/type/rsvp.rb

@@ -0,0 +1,35 @@
+module RMeetup
+  module Type
+    
+    # == RMeetup::Type::Rsvp
+    #
+    # Data wraper for a Rsvp fethcing response
+    # Used to access result attributes as well
+    # as progammatically fetch relative data types
+    # based on this rsvp.
+    
+    # Edited by Jason Berlinsky on 1/20/11 to allow for arbitrary data access
+    # See http://www.meetup.com/meetup_api/docs/ew/rsvps/ for available fields
+    
+    class Rsvp
+      attr_accessor :rsvp
+      
+      def initialize(rsvp = {})
+        self.rsvp = rsvp
+      end
+      
+      def method_missing(id, *args)
+        return self.rsvp[id.id2name]
+      end
+      
+      # Special accessors that need typecasting or other parsing
+      
+      def lat
+        return self.rsvp['lat'].to_f
+      end
+      def lon
+        return self.rsvp['lon'].to_f
+      end
+    end
+  end
+end