tweetkit 0.1.4 → 0.2.0

data/lib/tweetkit/connection.rb

@@ -1,12 +1,14 @@
 require 'faraday'
 require 'faraday_middleware'
 require 'tweetkit/auth'
-require 'tweetkit/default'
 require 'tweetkit/response'
 
 module Tweetkit
   module Connection
     include Tweetkit::Auth
+    include Tweetkit::Response
+
+    attr_accessor :previous_query, :previous_url
 
     BASE_URL = 'https://api.twitter.com/2/'
 
@@ -14,82 +16,99 @@ module Tweetkit
       request :get, endpoint, parse_query_and_convenience_headers(options)
     end
 
+    def post(endpoint, **options)
+      request :post, endpoint, parse_query_and_convenience_headers(options)
+    end
+
+    def put(endpoint, **options)
+      request :put, endpoint, parse_query_and_convenience_headers(options)
+    end
+
+    def delete(endpoint, **options)
+      request :delete, endpoint, parse_query_and_convenience_headers(options)
+    end
+
     def request(method, endpoint, data, **options)
-      auth_type = options.delete(:auth_type)
       url = URI.parse("#{BASE_URL}#{endpoint}")
+      @previous_url = url
+      @previous_query = data
 
-      if method == :get
-        conn = Faraday.new(params: data) do |c|
-          if auth_type == 'oauth1'
-            c.request :oauth, consumer_key: @consumer_key, consumer_secret: @consumer_secret
-          else
-            c.authorization :Bearer, @bearer_token
-          end
-        end
-        response = conn.get(url)
-      else
-        conn = Faraday.new do |f|
+      connection = Faraday.new do |conn|
+        if token_auth?
+          conn.request :oauth, consumer_key: @consumer_key, consumer_secret: @consumer_secret,
+                               token: @access_token, token_secret: @access_token_secret
+        elsif bearer_auth?
+          conn.request :authorization, 'Bearer', @bearer_token
+        else
+          raise NotImplementedError, 'No known authentication types were configured'
         end
-        response = conn.post(url)
       end
-      conn.close
-      Tweetkit::Response.new(response)
+
+      response = case method
+                 when :get
+                   connection.get(url, data)
+                 when :post
+                   connection.post(url, data.to_json, 'Content-Type' => 'application/json')
+                 when :put
+                   connection.put(url, data.to_json, 'Content-Type' => 'application/json')
+                 when :delete
+                   connection.delete(url, data.to_json, 'Content-Type' => 'application/json')
+                 end
+
+      Tweetkit::Response::Tweets.new response, connection: connection, twitter_request: { previous_url: @previous_url, previous_query: @previous_query }
     rescue StandardError => e
       raise e
     end
 
-    def auth_token(type = 'bearer')
-      case type
-      when 'bearer'
-        @bearer_token
-      end
-    end
-
     def build_fields(options)
       fields = {}
-      _fields = options.delete(:fields)
-      if _fields && _fields.size > 0
-        _fields.each do |key, value|
-          if value.is_a?(Array)
-            _value = value.join(',')
+      fields_ = options.delete(:fields)
+
+      if fields_ && !fields_.empty?
+        fields_.each do |field, value|
+          if value.is_a? Array
+            value = value.join(',')
           else
-            _value = value.delete(' ')
+            value = value.delete(' ')
           end
-          _key = key.to_s.gsub('_', '.')
-          fields.merge!({ "#{_key}.fields" => _value })
+
+          field = field.to_s.gsub('_', '.')
+          fields.merge!({ "#{field}.fields" => value })
         end
       end
+
       options.each do |key, value|
-        if key.match?('_fields')
-          if value.is_a?(Array)
-            _value = value.join(',')
-          else
-            _value = value.delete(' ')
-          end
-          _key = key.to_s.gsub('_', '.')
-          options.delete(key)
-          fields.merge!({ _key => _value })
+        next unless key.match? '_fields'
+
+        options.delete(key)
+
+        if value.is_a? Array
+          value = value.join(',')
+        else
+          value = value.delete(' ')
         end
+
+        key = key.to_s.gsub('_', '.')
+        fields.merge!({ key => value })
       end
+
       fields
     end
 
     def build_expansions(options)
-      expansions = {}
-      _expansions = options.delete(:expansions)
-      if _expansions && _expansions.size > 0
-        _expansions = _expansions.join(',')
-        expansions.merge!({ expansions: _expansions })
-      end
-      expansions
+      expansions = options.delete(:expansions)
+      return unless expansions
+
+      expansions = expansions.join(',') if expansions.is_a? Array
+      { expansions: expansions }
     end
 
     def parse_query_and_convenience_headers(options)
       options = options.dup
       fields = build_fields(options)
-      options.merge!(fields)
+      options.merge!(fields) if fields
       expansions = build_expansions(options)
-      options.merge!(expansions)
+      options.merge!(expansions) if expansions
       options
     end
   end