traitify 1.8.4 → 2.0.1

data/lib/traitify/error.rb

@@ -3,33 +3,35 @@ module Traitify
     attr_accessor :response
 
     def self.from(response)
-      if klass = case response.status
-                 when 400 then Traitify::BadRequest
-                 when 401 then Traitify::Unauthorized
-                 when 404 then Traitify::NotFound
-                 when 422 then Traitify::UnprocessableEntity
-                 when 500..505 then Traitify::ServerError
-                 end
-        klass.new(response)
+      klass = case response.status
+      when 400 then Traitify::BadRequest
+      when 401 then Traitify::Unauthorized
+      when 404 then Traitify::NotFound
+      when 422 then Traitify::UnprocessableEntity
+      when 500..505 then Traitify::ServerError
       end
+
+      klass.new(response) if klass
     end
 
     def initialize(response)
       @response = response
-      super(error_message)
-    end
 
-    def errors
-      response.body
+      super(error_message)
     end
 
     private
+
     def error_message
-      message =  "#{response.method.upcase} | "
-      message << "#{response.url.to_s} | "
+      message =  "#{response.request.http_method.upcase} | "
+      message << "#{response.request.url} | "
       message << "#{response.status} | "
-      message << (response.body.is_a?(Hash) ?
-        "#{response.body["message"]}" : "#{response.body.first["message"]}")
+
+      error = response.body
+      error = error.first if error.is_a?(Array)
+      error = error.message if error.respond_to?(:message)
+
+      message << error.to_s if error.present?
       message
     end
   end

data/lib/traitify/middleware/formatter.rb

@@ -0,0 +1,52 @@
+module Traitify
+  module Middleware
+    class Formatter
+      extend Forwardable
+
+      attr_accessor :logger, :options
+
+      def initialize(logger:, options:)
+        @logger = logger
+        @options = {log_level: :info, prefix: "[traitify-ruby]"}.merge(options)
+      end
+
+      def_delegators :@logger, :debug, :info, :warn, :error, :fatal
+
+      def request(env)
+        log(env[:method].upcase, env.url.to_s)
+        log("AUTH", env.request_headers["Authorization"], level: :debug)
+        log("BODY", env.body)
+        log("PARAMS", query_params(env))
+      end
+
+      def response(env)
+        log("STATUS", env.status)
+      end
+
+      private
+
+      def log(name, object, level: nil)
+        return unless object
+
+        log = proc {
+          "#{name}: #{object.respond_to?(:to_str) ? object.to_str : object.pretty_inspect&.strip}"
+        }
+
+        public_send(level || log_level, options[:prefix], &log)
+      end
+
+      def log_level
+        unless [:debug, :info, :warn, :error, :fatal].include?(options[:log_level])
+          return :info
+        end
+
+        options[:log_level]
+      end
+
+      def query_params(env)
+        env.request.params_encoder ||= Faraday::Utils.default_params_encoder
+        env.params_encoder.decode(env.url.query)
+      end
+    end
+  end
+end

data/lib/traitify/middleware/raise_error.rb

@@ -0,0 +1,38 @@
+# NOTE: Traitified version of Faraday error response middleware
+# https://github.com/lostisland/faraday/blob/b3b922949d14f604ed11dc0f749455fc062777e7/lib/faraday/response/raise_error.rb
+module Traitify
+  module Middleware
+    class RaiseError < Faraday::Middleware
+      def on_complete(env)
+        error = Traitify::Error.from(error_data(env))
+
+        raise error if error
+      end
+
+      private
+
+      def error_data(env)
+        Traitify::Data.new(
+          body: env.body,
+          headers: env.response_headers,
+          request: {
+            body: env.request_body,
+            headers: env.request_headers,
+            http_method: env[:method],
+            query: query_params(env),
+            url: env.url,
+            url_path: env.url.path
+          },
+          status: env.status
+        )
+      end
+
+      def query_params(env)
+        env.request.params_encoder ||= Faraday::Utils.default_params_encoder
+        env.params_encoder.decode(env.url.query)
+      end
+    end
+  end
+end
+
+Faraday::Response.register_middleware(raise_traitify_error: Traitify::Middleware::RaiseError)

data/lib/traitify/response.rb

@@ -0,0 +1,44 @@
+module Traitify
+  class Response
+    attr_reader :request
+
+    def initialize(request)
+      @request = request
+    end
+
+    def data
+      @data ||= Traitify::Data.new(request.body)
+    end
+
+    def page
+      @page ||= begin
+        page = {}
+
+        if request.env.response_headers["link"]
+          links = request.env.response_headers["link"].split(",")
+          if prev_link = links.find{ |link| link.include?("rel=\"prev\"") }
+            prev_link = prev_link.split(/>|</)[1]
+            page[:previous] = {
+              url: prev_link,
+              params: CGI.parse(prev_link.split("?")[1..-1].join("?"))
+            }
+          end
+
+          if next_link = links.find{ |link| link.include?("rel=\"next\"") }
+            next_link = next_link.split(/>|</)[1]
+            page[:next] = {
+              url: next_link,
+              params: CGI.parse(next_link.split("?")[1..-1].join("?"))
+            }
+          end
+        end
+
+        Traitify::Data.new page
+      end
+    end
+
+    def total
+      @total ||= request.env.response_headers["x-total-count"]
+    end
+  end
+end

data/lib/traitify/version.rb

@@ -1,3 +1,3 @@
 module Traitify
-  VERSION = "1.8.4"
+  VERSION = "2.0.1".freeze
 end

data/lib/traitify.rb

@@ -1,13 +1,41 @@
-require "traitify/version"
 require "traitify/configuration"
 require "traitify/client"
+require "traitify/data"
+require "traitify/error"
+require "traitify/response"
+require "traitify/version"
+require "logger"
+require "active_support"
+require "active_support/core_ext/object/deep_dup"
 
 module Traitify
   extend Configuration
 
+  self.host = "http://api-sandbox.traitify.com"
+  self.version = "v1"
+  self.locale_key = "en-us"
+
   class << self
+    attr_writer :logger
+
     def new(options = {})
       Traitify::Client.new(options)
     end
+
+    def logger
+      @logger ||= Logger.new($stdout).tap do |log|
+        log.progname = name
+      end
+    end
+
+    def log(level, message)
+      message = "[traitify-ruby] #{message}"
+      case level
+      when :debug
+        logger.debug message
+      else
+        logger.info message
+      end
+    end
   end
 end