rubymeetup 3.0

data/lib/rmeetup.rb

@@ -0,0 +1,82 @@
+require 'net/http'
+require 'date'
+require 'rubygems'
+require 'json'
+require 'rmeetup/type'
+require 'rmeetup/collection'
+require 'rmeetup/fetcher'
+require 'rmeetup/poster'
+
+module RMeetup
+  
+  # RMeetup Errors
+  class NotConfiguredError < StandardError
+    def initialize
+      super "Please provide your Meetup API key before fetching data."
+    end
+  end
+  
+  class InvalidRequestTypeError < StandardError
+    def initialize(type)
+      super "Fetch type '#{type}' not a valid."
+    end
+  end
+  
+  # == RMeetup::Client
+  # 
+  # Essentially a simple wrapper to delegate requests to
+  # different fetcher classes who are responsible for fetching
+  # and parsing their own responses.
+  class Client
+    FETCH_TYPES = [:topics, :cities, :members, :rsvps, :events, :groups, :comments, :photos]
+    
+    POST_TYPES = [:event_comment]
+    # Meetup API Key
+    # Get one at http://www.meetup.com/meetup_api/key/
+    # Needs to be the group organizers API Key
+    # to be able to RSVP for other people
+    @@api_key = nil
+    def self.api_key; @@api_key; end;
+    def self.api_key=(key); @@api_key = key; end;
+    
+    def self.fetch(type, options = {})
+      check_configuration!
+      
+      # Merge in all the standard options
+      # Keeping whatever was passed in
+      options = default_options.merge(options)
+      
+      if FETCH_TYPES.include?(type.to_sym)
+        # Get the custom fetcher used to manage options, api call to get a type of response
+        fetcher = RMeetup::Fetcher.for(type)
+        return fetcher.fetch(options)
+      else
+        raise InvalidRequestTypeError.new(type)
+      end
+    end
+
+    def self.post(type, options = {})
+      check_configuration!
+      options = default_options.merge(options)
+      
+      if POST_TYPES.include?(type.to_sym)
+        poster = RMeetup::Poster.for(type)
+        return poster.post(options)
+      else
+        raise InvalidRequestTypeError.new(type)
+      end
+    end
+    protected
+      def self.default_options
+        {
+          :key => api_key
+        }
+      end
+      
+      # Raise an error if RMeetup has not been
+      # provided with an api key
+      def self.check_configuration!
+        raise NotConfiguredError.new unless api_key
+      end
+  end
+end

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.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/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/poster.rb

@@ -0,0 +1,17 @@
+require "rmeetup/poster/base"
+require "rmeetup/poster/event_comment"
+
+module RMeetup
+  module Poster
+    
+    class << self
+      # Return a fetcher for given type
+      def for(type)
+        return  case type.to_sym
+                when :event_comment
+                  EventComment.new
+                end
+      end 
+    end
+  end
+end

data/lib/rmeetup/poster/base.rb

@@ -0,0 +1,81 @@
+require 'net/http'
+require 'net/https'
+
+module RMeetup
+  module Poster
+    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 post(options = {})
+        url = build_url(options)
+        ret = post_response(url, options)
+        ret
+      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)
+          base_url
+        end
+      
+        def base_url
+          "https://api.meetup.com/2/#{@type}/"
+        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 post_response(url, options)
+          sslurl = URI.parse(url)
+          https = Net::HTTP.new(sslurl.host, sslurl.port)
+          https.use_ssl = true
+          req = Net::HTTP::Post.new(sslurl.path)
+          req.set_form_data(options)
+          resp = https.request(req)
+        end
+    end
+  end
+end

data/lib/rmeetup/poster/event_comment.rb

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

data/lib/rmeetup/type.rb

@@ -0,0 +1,8 @@
+require "rmeetup/type/topic"
+require "rmeetup/type/group"
+require "rmeetup/type/city"
+require "rmeetup/type/member"
+require "rmeetup/type/rsvp"
+require "rmeetup/type/event"
+require "rmeetup/type/comment"
+require "rmeetup/type/photo"

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

data/lib/rmeetup/type/topic.rb

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

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: rubymeetup
+version: !ruby/object:Gem::Version
+  version: '3.0'
+  prerelease: 
+platform: ruby
+authors:
+- Joshua Calloway
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-15 00:00:00.000000000 Z
+dependencies: []
+description: A gem that accesses meetup api
+email: joshua.calloway@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rmeetup.rb
+- lib/rmeetup/collection.rb
+- lib/rmeetup/fetcher.rb
+- lib/rmeetup/poster.rb
+- lib/rmeetup/type.rb
+- lib/rmeetup/poster/base.rb
+- lib/rmeetup/poster/event_comment.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/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
+homepage: http://rubygems.org/gems/rubymeetup
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: rubymeetup
+test_files: []