drink-socially 0.0.4

data/lib/drink-socially/api/credential.rb

@@ -0,0 +1,69 @@
+require 'cgi'
+
+module NRB
+  module Untappd
+    class API
+
+    private
+
+      class Credential
+
+        class IncompleteCredentialError < ArgumentError; end
+
+        def self.valid_attrs
+          [ :access_token, :client_id, :client_secret ]
+        end
+
+
+        def initialize(opts={})
+          opts.slice!(*self.class.valid_attrs)
+          @creds = {}
+          !! opts[:access_token]  && @creds[:access_token] = CGI::escape(opts[:access_token])
+          !! opts[:client_id]     && @creds[:client_id] = CGI::escape(opts[:client_id])
+          !! opts[:client_secret] && @creds[:client_secret] = CGI::escape(opts[:client_secret])
+          raise IncompleteCredentialError.new('Provide either API access token or API client id & secret') unless valid?
+        end
+
+        valid_attrs.each do |m|
+          define_method m do
+            @creds[m]
+          end
+        end
+
+
+        def is_client?
+          !! @creds[:client_id] && !! @creds[:client_secret]
+        end
+        alias_method :is_app?, :is_client?
+
+
+        def is_user?
+          !! @creds[:access_token]
+        end
+
+
+        def merge(hash)
+          @creds.merge(hash)
+        end
+
+
+        def to_h
+          @creds
+        end
+
+
+        def to_param
+          @creds.map { |k,v| "#{k}=#{v}" }.join("&")
+        end
+
+      private
+
+        def valid?
+          (is_client? || is_user?) && ! (is_client? && is_user?)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/drink-socially/api/notification.rb

@@ -0,0 +1,13 @@
+module NRB
+  module Untappd
+    class API
+      class Notification
+
+        def initialize(response)
+        
+        end
+
+      end
+    end
+  end
+end

data/lib/drink-socially/api/object.rb

@@ -0,0 +1,83 @@
+module NRB
+  module Untappd
+    class API
+      class Object < HTTPService::Response
+
+        attr_reader :attributes, :error_message, :pagination, :results
+
+        def initialize(args)
+          super
+          parse_error_response
+          setup_pagination(args)
+          extract_results args[:results_path]
+        end
+
+      private
+
+        def define_attributes_from(hash)
+          return unless hash.respond_to?(:keys)
+          @attributes ||= []
+          perform_unless_respond_to(hash.keys) do |attr|
+            @attributes.push(attr.to_sym)
+          end
+        end
+
+
+        def define_methods_from(hash)
+          return unless hash.respond_to?(:keys)
+          perform_unless_respond_to(hash.keys) do |meth|
+            define_singleton_method meth, lambda { hash[meth] }
+          end
+        end
+
+
+        def extract_from_body(path)
+          return unless !! body
+          path.inject(body) do |node,method_name|
+            break unless node.respond_to? method_name
+            node.send method_name
+          end
+        end
+
+
+        def extract_results(path)
+          @results = extract_from_body path if !! path
+          define_attributes_from @results
+          define_methods_from @results
+        end
+
+
+        def parse_error_response
+          return unless errored?
+          @error_message = if body[:meta]
+            "[#{body[:meta][:error_type]}] #{body[:meta][:error_detail]}"
+
+          elsif body[:error]
+            body[:error]
+
+          else
+            "Could not parse error message from response body"
+          end
+        end
+
+
+        def perform_unless_respond_to(arr)
+          return unless arr.respond_to?(:each)
+          arr.each do |key|
+            unless respond_to?(key)
+              yield key
+            end
+          end
+        end
+
+
+        def setup_pagination(args)
+          @paginator = args[:paginator_class] || NRB::Untappd::API::Pagination
+          @pagination = @paginator.from_response self
+        end
+
+      end
+    end
+  end
+end
+

data/lib/drink-socially/api/pagination.rb

@@ -0,0 +1,73 @@
+require 'uri'
+module NRB
+  module Untappd
+    class API
+      class Pagination
+
+        def self.from_response(response)
+          # It's duck types (almost) all the way down
+          return unless response.respond_to?(:body) &&
+                        response.body.respond_to?(:response) &&
+                        response.body.response.respond_to?(:pagination) &&
+                        !! response.body.response.pagination
+          new response.body.response.pagination
+        end
+
+
+        def initialize(pagination)
+          @api_max_id = pagination[:max_id].to_i
+          @uris   = { api_next: URI.parse(pagination[:next_url]),
+                      api_prev: URI.parse(pagination[:since_url]),
+                      api_since: URI.parse(pagination[:since_url])
+                    }
+        end
+
+
+        def next_id
+          @api_max_id + 1
+        end
+
+
+        # Warning: The API will return the most recent results if next_id is
+        #          greater than the most recent result
+        def next_uri
+          uri_for query: "since=#{next_id}", uri: :next
+        end
+
+
+        def next_url
+          next_uri.to_s
+        end
+
+
+        def prev_id
+          @api_max_id - 1
+        end
+        alias_method :previous_id, :prev_id
+
+
+        def prev_uri
+          uri_for query: "max_id=#{prev_id}", uri: :prev
+        end
+        alias_method :previous_uri, :prev_uri
+
+
+        def prev_url
+          prev_uri.to_s
+        end
+        alias_method :previous_url, :prev_url
+
+      private
+
+        def uri_for(opts)
+          return nil unless !! opts[:uri]
+          return @uris[otps[:uri]] if @uris[opts[:uri]]
+          @uris[otps[:uri]] = @uris["api_#{opts[:uri]}".to_sym]
+          @uris[otps[:uri]].query = opts[:query] if opts[:query]
+          @uris[otps[:uri]]
+        end
+
+      end
+    end
+  end
+end

data/lib/drink-socially/api/rate_limit.rb

@@ -0,0 +1,17 @@
+module NRB
+  module Untappd
+    class API
+      class RateLimit
+
+        attr_reader :limit, :remaining
+
+        def initialize(headers)
+          return unless headers.respond_to?(:[])
+          @limit     = headers["x-ratelimit-limit"]
+          @remaining = headers["x-ratelimit-remaining"]
+        end
+
+      end
+    end
+  end
+end

data/lib/drink-socially/api/url_tokenizer.rb

@@ -0,0 +1,47 @@
+require 'strscan'
+module NRB
+  module Untappd
+    class API
+      class URLTokenizer
+        attr_reader :map, :string
+
+        def initialize(args)
+          @map = args[:map]
+          @string = args[:string]
+          raise ArgumentError unless @map && @string
+        end
+
+
+        def tr
+          return @string unless @string =~ /:[#{word_chars}]+:/
+          result = ""
+          s = StringScanner.new(@string)
+          until s.eos? do
+            word = s.scan(/:[#{word_chars}]+:|[#{url_chars}]+/)
+            raise RuntimeError.new("String Scanner failed. File a bug.") if word.nil?
+            result += tr_word(word)
+          end
+          result
+        end
+
+      private
+
+        def tr_word(word)
+          return word unless word =~ /:([#{word_chars}]+):/
+          return map[$1.to_sym].to_s
+        end
+
+
+        def url_chars
+          word_chars + Regexp.quote('/')
+        end
+
+
+        def word_chars
+          "0-9a-zA-Z" + Regexp.quote("$-_.+!*'(),")
+        end
+
+      end
+    end
+  end
+end

data/lib/drink-socially/config.rb

@@ -0,0 +1,48 @@
+require 'yaml'
+
+module NRB
+  module Untappd
+    class Config
+
+      class NoConfig < ArgumentError; end
+
+      extend Forwardable
+
+      attr_reader :data
+
+      def_delegators :@data, :[], :each, :keys
+
+      def initialize(args)
+        load_data(args)
+        define_accessors
+      end
+
+    private
+
+      def define_accessors
+        return unless @data
+        @data.keys.each do |name|
+          unless respond_to?(name)
+            define_singleton_method name, lambda { data[name] }
+          end
+        end
+      end
+
+
+      def find_stream(args)
+        if args[:filename]
+          File.open args[:filename]
+        end
+      end
+
+
+      def load_data(args)
+        args[:stream] ||= find_stream(args)
+        raise NoConfig.new("Please supply :filename or :stream to Config.new") unless !! args[:stream]
+        loader = args[:stream_loader] || YAML
+        @data = loader.load_stream(args[:stream])[0]
+      end
+
+    end
+  end
+end

data/lib/drink-socially/extensions/hash.rb

@@ -0,0 +1,17 @@
+class Hash
+
+  def slice(*keys)
+    hash = self.class.new
+    keys.each { |k| hash[k] = self[k] if has_key?(k) }
+    hash
+  end
+
+
+  def slice!(*keys)
+    omit = slice(*self.keys - keys)
+    hash = slice(*keys)
+    replace(hash)
+    omit
+  end
+
+end

data/lib/drink-socially/http_service.rb

@@ -0,0 +1,61 @@
+require 'faraday'
+require 'faraday_middleware/parse_oj'
+
+module NRB
+  class HTTPService
+
+    autoload :Response, 'drink-socially/http_service/response'
+
+    DEFAULT_MIDDLEWARE = Proc.new do |faraday| 
+      faraday.adapter Faraday.default_adapter
+      faraday.request  :url_encoded
+      faraday.response :oj
+    end
+
+    class << self
+      attr_accessor :faraday_middleware
+
+      def default_middleware; DEFAULT_MIDDLEWARE; end
+      def default_http_class; Faraday; end
+      def default_response_class; Response; end
+
+
+      def make_request(args={}, connection_opts={})
+        new(args,connection_opts).make_request
+      end
+
+    end
+
+    self.faraday_middleware = self.default_middleware
+
+
+    def initialize(args={}, connection_opts={})
+      @connection_opts = connection_opts
+      @response_class = args.delete(:response_class) || self.class.default_response_class
+      @verb = args.delete(:verb)
+      @url = args.delete(:url)
+      @params = process_args(args)
+      @args = args
+    end
+
+
+    def make_request
+      connection = self.class.default_http_class.new @url, @connection_opts, &self.class.faraday_middleware
+      response = connection.send @verb, @url, @params
+      args = @args.merge( { body: response.body, headers: response.headers, status: response.status.to_i } )
+      @response_class.new args
+    rescue Faraday::Error::ParsingError => e
+      self.class.default_response_class.new body: {error: e.message}, status: 500
+    end
+
+  private
+
+    attr_reader :params, :verb, :url
+
+    def process_args(args)
+      return args unless @verb == :post
+      args.inject("") { |str,pair| str += "#{pair.first}=#{pair.last}&" }.chop
+    end
+
+  end
+end

data/lib/drink-socially/http_service/response.rb

@@ -0,0 +1,27 @@
+require 'hashie'
+
+module NRB
+  class HTTPService
+    class Response
+
+      attr_reader :status, :body, :headers
+
+      def errored?
+        ! success?
+      end
+
+
+      def initialize(args)
+        @status = args[:status]
+        @body = Hashie::Mash.new args[:body]
+        @headers = Hashie::Mash.new args[:headers]
+      end
+
+
+      def success?
+        @status >= 200 && @status < 300
+      end
+
+    end
+  end
+end