drink-socially 0.0.4

data/README.md

@@ -0,0 +1,54 @@
+# drink-socially
+
+[![Build Status](https://secure.travis-ci.org/NewRepublicBrewing/drink-socially.png)](http://travis-ci.org/NewRepublicBrewing/drink-socially)
+[![Dependency Status](https://gemnasium.com/NewRepublicBrewing/drink-socially.png)](https://gemnasium.com/NewRepublicBrewing/drink-socially)
+[![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/NewRepublicBrewing/drink-socially)
+
+A gem for interfacing with the Untappd API
+
+## Requirements
+
+Ruby 1.9
+
+## Usage
+
+### Acting as a person
+
+```ruby
+require 'drink-socially'
+
+# Per-user access token taken from OAuth
+brundage = NRB::Untappd::API.new access_token: '7A23A8BEER81D2580E&CEFC405C60693AC476AA'
+
+new_republic = brundage.brewery_info 8767
+=> #<Hashie::Mash beer_count=13 beer_list=....
+
+new_republic.brewery_name
+ => "New Republic Brewing Company" 
+
+```
+
+### Acting as an app
+
+```ruby
+# Get your id & secret from http://untappd.com/api/dashboard
+new_republic_app = NRB::Untappd::API.new client_id: '645c10bc59f30e34d6fd265cfdeb75e', client_secret: '9ffe686c814207df12f9b0e0bc0cdab'
+```
+
+## Methods
+
+### NRB::Untappd::API
+
+`new` takes a user access token or a application id and secret. Once you have an instance of the API you can make calls on behalf of the user or application.
+
+The Untappd api enforces a rate limit per token.  After the first call you can ask your object the current limit with the `rate_limit` call.
+
+```
+brundage.rate_limit
+ => @rate_limit= #<NRB::Untappd::API::RateLimit:0x930af6c @limit="100", @remaining="99">>
+```
+
+All API calls return an `NRB::Untappd::API::Response` object. You can access the full response object with the `last_response` method.
+
+Full documentation for the API calls are detailed [in the wiki](drink-socially/wiki/api_calls).  Also have a look at the [Untappd v4 API documentation](http://untappd.com/api/docs/v4) for details.
+

data/config/endpoints.yml

@@ -0,0 +1,231 @@
+---
+:accept_friend:
+  :endpoint: "friend/accept/:user_id:"
+  :required_args:
+    - :user_id
+  :verb: :post
+
+:add_comment:
+  :endpoint: "checkin/addcomment/:checkin_id:"
+  :required_args:
+    - :checkin_id
+    - :comment
+  :results_path:
+    - :response
+    - :comments
+    - :items
+  :verb: :post
+
+:add_to_wish_list:
+  :endpoint: user/wishlist/add
+  :method_aliases:
+    - :add_to_wishlist
+  :required_args:
+    - :bid
+  :results_path:
+    - :response
+    - :beer
+
+:beer_checkins:
+  :endpoint: "beer/checkins/:bid:"
+  :method_aliases:
+    - :beer_feed
+  :required_args:
+    - :bid
+  :results_path:
+    - :response
+    - :checkins
+    - :items
+
+:beer_info:
+  :endpoint: "beer/info/:bid:"
+  :required_args:
+    - :bid
+  :results_path:
+    - :response
+    - :beer
+
+:beer_search:
+  :endpoint: search/beer
+  :required_args:
+    - :q
+
+:brewery_checkins:
+  :endpoint: "brewery/checkins/:brewery_id:"
+  :method_aliases:
+    - :brewery_feed
+  :required_args:
+    - :brewery_id
+  :results_path:
+    - :response
+    - :checkins
+    - :items
+
+:brewery_info:
+  :endpoint: "brewery/info/:brewery_id:"
+  :required_args:
+    - :brewery_id
+  :results_path:
+    - :response
+    - :brewery
+
+:brewery_search:
+  :endpoint: search/brewery
+  :required_args:
+    - :q
+  :results_path:
+    - :response
+    - :brewery
+    - :items
+
+:checkin_info:
+  :endpoint: "checkin/view/:checkin_id:"
+  :required_args:
+    - :checkin_id
+  :results_path:
+    - :response
+    - :checkin
+
+:delete_comment:
+  :endpoint: "checkin/deletecomment/:comment_id:"
+  :method_aliases:
+    - :remove_comment
+  :required_args:
+    - :comment_id
+  :results_path:
+    - :response
+    - :comments
+  :verb: :post
+
+:foursquare_venue_info:
+  :endpoint: "venue/foursquare_lookup/:venue_id:"
+  :required_args:
+    - :venue_id
+  :results_path:
+    - :response
+    - :venue
+    - :items
+    - :first
+  :verb: :post
+
+:friend_feed:
+  :endpoint: checkin/recent
+  :results_path:
+    - :response
+    - :checkins
+    - :items
+
+:news:
+  :endpoint: notifications
+  :results_path:
+    - :response
+    - :news
+    - :items
+
+:notifications:
+  :endpoint: notifications
+  :results_path:
+    - :response
+    - :notifications
+    - :items
+
+:pending_friends:
+  :endpoint: user/pending
+  :results_path:
+    - :response
+
+:reject_friend:
+  :endpoint: "friend/reject/:user_id:"
+  :required_args:
+    - :user_id
+  :verb: :post
+
+:remove_friend:
+  :endpoint: "friend/remove/:user_id:"
+  :required_args:
+    - :user_id
+
+:remove_from_wish_list:
+  :endpoint: user/wishlist/remove
+  :method_aliases:
+    - :delete_from_wish_list
+  :required_args:
+    - :bid
+
+:request_friend:
+  :endpoint: "friend/request/:user_id:"
+  :required_args:
+    - :user_id
+
+:the_pub:
+  :endpoint: thepub
+  :results_path:
+    - :response
+    - :checkins
+    - :items
+
+:trending:
+  :endpoint: beer/trending
+
+:toast:
+  :endpoint: "checkin/toast/:checkin_id:"
+  :method_aliases:
+    - :add_toast
+    - :delete_toast
+  :required_args:
+    - :checkin_id
+
+:user_badges:
+  :endpoint: "user/badges/:username:"
+
+:user_distinct_beers:
+  :endpoint: "user/beers/:username:"
+  :method_aliases:
+    - :user_beers
+  :results_path:
+    - :response
+    - :beers
+    - :items
+
+:user_feed:
+  :endpoint: "user/checkins/:username:"
+  :results_path:
+    - :response
+    - :checkins
+    - :items
+
+:user_friends:
+  :endpoint: "user/friends/:username:"
+  :results_path:
+    - :response
+    - :items
+
+:user_info:
+  :endpoint: "user/info/:username:"
+  :results_path:
+    - :response
+    - :user
+
+:user_wish_list:
+  :endpoint: "user/wishlist/:username:"
+  :results_path:
+    - :response
+    - :beers
+    - :items
+
+:venue_feed:
+  :endpoint: "venue/checkins/:venue_id:"
+  :required_args:
+    - :venue_id
+  :results_path:
+    - :response
+    - :checkins
+    - :items
+
+:venue_info:
+  :endpoint: "venue/info/:venue_id:"
+  :required_args:
+    - :venue_id
+  :results_path:
+    - :response
+    - :venue

data/lib/drink-socially.rb

@@ -0,0 +1,43 @@
+require 'drink-socially/http_service'
+require 'drink-socially/version'
+require 'drink-socially/extensions/hash'
+
+module NRB
+  module Untappd
+
+    autoload :API,       'drink-socially/api'
+    autoload :Config,    'drink-socially/config'
+
+    class << self
+
+      attr_accessor :http_service
+
+      def config_file_path(key)
+        return key if File.absolute_path(key) == key
+        File.expand_path( File.join( config_dir, key ) )
+      end
+
+
+      def load_config(args)
+        reader = args.delete(:config_reader) || Config
+        !! args[:filekey] && args[:filename] = config_file_path(args.delete(:filekey))
+        reader.new(args)
+      end
+
+
+      def make_request(args)
+        http_service.make_request args
+      end
+
+    private
+
+      def config_dir
+        File.expand_path( File.join( File.dirname(__FILE__), '..', 'config' ) ) 
+      end
+
+    end
+
+    self.http_service = HTTPService
+
+  end
+end

data/lib/drink-socially/api.rb

@@ -0,0 +1,124 @@
+module NRB
+  module Untappd
+    class API
+
+      API_VERSION = :v4           # Use NRB::Untappd::API.api_version instead
+      SERVER = 'api.untappd.com'  # Use NRB::Untappd::API.server instead
+
+      autoload :Credential,      'drink-socially/api/credential'
+      autoload :Pagination,      'drink-socially/api/pagination'
+      autoload :RateLimit,       'drink-socially/api/rate_limit'
+      autoload :Object,          'drink-socially/api/object'
+      autoload :URLTokenizer, 'drink-socially/api/url_tokenizer'
+
+      attr_reader :credential, :endpoints, :rate_limit
+
+      def self.api_version; API_VERSION; end
+      def self.default_rate_limit_class; RateLimit; end
+      def self.default_response_class; Object; end
+      def self.requestor; NRB::Untappd; end
+      def self.server; SERVER; end
+
+
+      # http://untappd.com/api/docs/v4#checkin
+      # Required args: bid
+      def add_checkin(args)
+        validate_api_args args, :bid
+        t = Time.now
+        args[:endpoint] = 'checkin/add'
+        args[:gmt_offset] ||= t.gmt_offset / 3600
+        args[:timezone] ||= t.zone
+        args[:verb] = :post
+        api_call args
+      end
+
+
+      def api_call(args)
+        endpoint = args.delete(:endpoint)
+        config = get_config endpoint
+        return unless config
+
+        validate_api_args args, *config[:required_args]
+
+        args.merge!(config)
+
+        args[:response_class] ||= self.class.default_response_class
+
+        tokenizer = URLTokenizer.new map: args, string: args.delete(:endpoint)
+        args[:url] = find_path_at tokenizer.tr
+
+        response = self.class.requestor.make_request(args)
+        @rate_limit = self.class.default_rate_limit_class.new(response.headers)
+        response
+      end
+
+
+      def initialize(args={})
+        @api_version = args[:api_version] || self.class.api_version
+        @credential = args[:credential] || Credential.new(args.dup)
+        @server = args[:server] || self.class.server
+        define_endpoints_from(args)
+      end
+
+    private
+
+      def api_call_lambda(args)
+        lambda { |opts={}| api_call opts.merge({endpoint: args[:endpoint]}) }
+      end
+
+      def credential_string_for_url
+        @credential.is_user? ? "?access_token=#{@credential.access_token}" : ""
+      end
+
+
+      def define_endpoint_aliases(args)
+        return unless args[:orig]
+        args[:aliases].each do |name|
+          define_singleton_method name, api_call_lambda(endpoint: name)
+        end
+      end
+
+
+      def define_endpoints_from(args)
+        @endpoints = args[:endpoints] || NRB::Untappd.load_config(filekey: (args[:config_file] || 'endpoints.yml'))
+        @endpoints.each do |endpoint,endpoint_config|
+          define_singleton_method endpoint, api_call_lambda(endpoint: endpoint)
+          endpoint_config[:method_aliases] && define_endpoint_aliases(orig: endpoint, aliases: endpoint_config[:method_aliases])
+        end
+      end
+
+
+      def endpoint_base
+        "http://#{@server}/#{@api_version}/"
+      end
+
+
+      def extract_info_from(response, *keys)
+        return unless response.success?
+        keys.inject(response.body) { |hash, key| hash[key] }
+      end
+
+
+      def find_path_at(endpoint)
+        endpoint_base + endpoint.to_s + credential_string_for_url
+      end
+
+
+      def get_config(endpoint)
+        config = @endpoints[endpoint]
+        return unless config
+        config[:verb] ||= :get
+        config
+      end
+
+
+      def validate_api_args(args, *required_args)
+        raise ArgumentError.new("Please supply a hash") unless args.is_a?(Hash)
+        required_args.each do |arg|
+          raise ArgumentError.new("Missing required #{arg} parameter") unless !! args[arg]
+        end
+      end
+
+    end
+  end
+end