active_campaign 0.0.12 → 0.1.1

data/lib/active_campaign/default.rb

@@ -0,0 +1,135 @@
+require 'active_campaign/version'
+require 'active_campaign/response/raise_error'
+require 'active_campaign/response/debugger'
+require 'active_campaign/response/json_normalizer'
+require 'active_campaign/response/mashify'
+require 'active_campaign/response/instrumentation'
+require 'active_campaign/response/parse_json'
+
+module ActiveCampaign
+
+  # Default configuration options for {Client}
+  module Default
+
+    # Default API endpoint
+    API_ENDPOINT = "https://subdomain.activehosted.com".freeze
+
+    API_PATH = "admin/api.php".freeze
+
+    # Default User Agent header string
+    USER_AGENT   = "ActiveCampaign Ruby Gem #{ActiveCampaign::VERSION}".freeze
+
+    # Default media type
+    MEDIA_TYPE   = "text/html"
+
+    # Default media type
+    API_OUTPUT   = "json"
+
+    # Default WEB endpoint
+    WEB_ENDPOINT = "http://www.activecampaign.com/".freeze
+
+    # Default Faraday middleware stack
+    MIDDLEWARE = Faraday::Builder.new do |builder|
+      builder.request  :url_encoded
+      builder.response :mashify
+      builder.response :json_normalizer
+      builder.response :parse_json
+      builder.use      :debugger
+      builder.use      :instrumentation
+      builder.adapter  Faraday.default_adapter
+    end
+
+    class << self
+
+      # Configuration options
+      # @return [Hash]
+      def options
+        Hash[ActiveCampaign::Configurable.keys.map{|key| [key, send(key)]}]
+      end
+
+      # Default API endpoint from ENV or {API_ENDPOINT}
+      # @return [String]
+      def api_endpoint
+        ENV['ACTIVE_CAMPAIGN_API_ENDPOINT'] || "#{API_ENDPOINT}/#{api_path}"
+      end
+
+      # Default API endpoint from ENV or {API_ENDPOINT}
+      # @return [String]
+      def api_path
+        API_PATH
+      end
+
+      # Default pagination preference from ENV
+      # @return [String]
+      def auto_paginate
+        ENV['ACTIVE_CAMPAIGN_AUTO_PAGINATE']
+      end
+
+      # Default options for Faraday::Connection
+      # @return [Hash]
+      def connection_options
+        {
+          :headers => {
+            :accept => default_media_type,
+            :user_agent => user_agent
+          }
+        }
+      end
+
+      # Default media type from ENV or {MEDIA_TYPE}
+      # @return [String]
+      def default_media_type
+        ENV['ACTIVE_CAMPAIGN_DEFAULT_MEDIA_TYPE'] || MEDIA_TYPE
+      end
+
+      # Default GitHub username for Basic Auth from ENV
+      # @return [String]
+      def api_key
+        ENV['ACTIVE_CAMPAIGN_API_KEY']
+      end
+
+      def debug
+        false
+      end
+
+      # Default middleware stack for Faraday::Connection
+      # from {MIDDLEWARE}
+      # @return [String]
+      def middleware
+        MIDDLEWARE
+      end
+
+      # Default media api_output from ENV or {API_OUTPUT}
+      # @return [String]
+      def api_output
+        ENV['ACTIVE_CAMPAIGN_API_OUTPUT'] || API_OUTPUT
+      end
+
+      # Default pagination page size from ENV
+      # @return [Fixnum] Page size
+      def per_page
+        page_size = ENV['ACTIVE_CAMPAIGN_PER_PAGE']
+
+        page_size.to_i if page_size
+      end
+
+      # Default proxy server URI for Faraday connection from ENV
+      # @return [String]
+      def proxy
+        ENV['ACTIVE_CAMPAIGN_PROXY']
+      end
+
+      # Default User-Agent header string from ENV or {USER_AGENT}
+      # @return [String]
+      def user_agent
+        ENV['ACTIVE_CAMPAIGN_USER_AGENT'] || USER_AGENT
+      end
+
+      # Default web endpoint from ENV or {WEB_ENDPOINT}
+      # @return [String]
+      def web_endpoint
+        ENV['ACTIVE_CAMPAIGN_WEB_ENDPOINT'] || WEB_ENDPOINT
+      end
+    end
+  end
+end

data/lib/active_campaign/error.rb

@@ -1,16 +1,54 @@
 module ActiveCampaign
-  # Custom error class for rescuing from all ActiveCampaign errors
+  # Custom error class for rescuing from all GitHub errors
   class Error < StandardError
+
+    # Returns the appropriate ActiveCampaign::Error sublcass based
+    # on status and response message
+    #
+    # @param [Hash]
+    # @returns [ActiveCampaign::Error]
+    def self.from_response(response)
+      status = response[:status].to_i
+      body  = response[:body].to_s
+
+      if klass =  case status
+                  when 400 then ActiveCampaign::BadRequest
+                  when 401 then ActiveCampaign::Unauthorized
+                  when 403
+                    if body =~ /rate limit exceeded/i
+                      ActiveCampaign::TooManyRequests
+                    elsif body =~ /login attempts exceeded/i
+                      ActiveCampaign::TooManyLoginAttempts
+                    else
+                      ActiveCampaign::Forbidden
+                    end
+                  when 404 then ActiveCampaign::NotFound
+                  when 406 then ActiveCampaign::NotAcceptable
+                  when 422 then ActiveCampaign::UnprocessableEntity
+                  when 500 then ActiveCampaign::InternalServerError
+                  when 501 then ActiveCampaign::NotImplemented
+                  when 502 then ActiveCampaign::BadGateway
+                  when 503 then ActiveCampaign::ServiceUnavailable
+                  end
+        klass.new(response)
+      end
+    end
+
     def initialize(response=nil)
       @response = response
       super(build_error_message)
     end
 
-    def response_body
-      @response_body ||=
+    private
+
+    def data
+      @data ||=
         if (body = @response[:body]) && !body.empty?
-          if body.is_a?(String)
-            MultiJson.load(body, :symbolize_keys => true)
+          if body.is_a?(String) &&
+            @response[:response_headers] &&
+            @response[:response_headers][:content_type] =~ /json/
+
+            Sawyer::Agent.serializer.decode(body)
           else
             body
           end
@@ -19,50 +57,78 @@ module ActiveCampaign
         end
     end
 
-    private
+    def response_message
+      case data
+      when Hash
+        data[:message]
+      when String
+        data
+      end
+    end
+
+    def response_error
+      "Error: #{data[:error]}" if data.is_a?(Hash) && data[:error]
+    end
+
+    def response_error_summary
+      return nil unless data.is_a?(Hash) && !Array(data[:errors]).empty?
+
+      summary = "\nError summary:\n"
+      summary << data[:errors].map do |hash|
+        hash.map { |k,v| "  #{k}: #{v}" }
+      end.join("\n")
+
+      summary
+    end
 
     def build_error_message
-      return nil  if @response.nil?
+      return nil if @response.nil?
 
-      message = if response_body
-        ": #{response_body[:error] || response_body[:message] || ''}"
-      else
-        ''
-      end
-      errors = unless message.empty?
-        response_body[:errors] ?  ": #{response_body[:errors].map{|e|e[:message]}.join(', ')}" : ''
-      end
-      "#{@response[:method].to_s.upcase} #{@response[:url].to_s}: #{@response[:status]}#{message}#{errors}"
+      message =  "#{@response[:method].to_s.upcase} "
+      message << "#{@response[:url].to_s}: "
+      message << "#{@response[:status]} - "
+      message << "#{response_message}" unless response_message.nil?
+      message << "#{response_error}" unless response_error.nil?
+      message << "#{response_error_summary}" unless response_error_summary.nil?
+      message
     end
   end
 
-  # Raised when ActiveCampaign returns a 400 HTTP status code
+  # Raised when GitHub returns a 400 HTTP status code
   class BadRequest < Error; end
 
-  # Raised when ActiveCampaign returns a 401 HTTP status code
+  # Raised when GitHub returns a 401 HTTP status code
   class Unauthorized < Error; end
 
-  # Raised when ActiveCampaign returns a 403 HTTP status code
+  # Raised when GitHub returns a 403 HTTP status code
   class Forbidden < Error; end
 
-  # Raised when ActiveCampaign returns a 404 HTTP status code
+  # Raised when GitHub returns a 403 HTTP status code
+  # and body matches 'rate limit exceeded'
+  class TooManyRequests < Forbidden; end
+
+  # Raised when GitHub returns a 403 HTTP status code
+  # and body matches 'login attempts exceeded'
+  class TooManyLoginAttempts < Forbidden; end
+
+  # Raised when GitHub returns a 404 HTTP status code
   class NotFound < Error; end
 
-  # Raised when ActiveCampaign returns a 406 HTTP status code
+  # Raised when GitHub returns a 406 HTTP status code
   class NotAcceptable < Error; end
 
-  # Raised when ActiveCampaign returns a 422 HTTP status code
+  # Raised when GitHub returns a 422 HTTP status code
   class UnprocessableEntity < Error; end
 
-  # Raised when ActiveCampaign returns a 500 HTTP status code
+  # Raised when GitHub returns a 500 HTTP status code
   class InternalServerError < Error; end
 
-  # Raised when ActiveCampaign returns a 501 HTTP status code
+  # Raised when GitHub returns a 501 HTTP status code
   class NotImplemented < Error; end
 
-  # Raised when ActiveCampaign returns a 502 HTTP status code
+  # Raised when GitHub returns a 502 HTTP status code
   class BadGateway < Error; end
 
-  # Raised when ActiveCampaign returns a 503 HTTP status code
+  # Raised when GitHub returns a 503 HTTP status code
   class ServiceUnavailable < Error; end
-end
+end

data/lib/active_campaign/response/debugger.rb

@@ -0,0 +1,42 @@
+require 'faraday'
+require 'forwardable'
+
+module ActiveCampaign
+  module Response
+    class Debugger < Faraday::Response::Middleware
+      extend Forwardable
+
+      def initialize(app, logger = nil)
+        super(app)
+        @logger = logger || begin
+          require 'logger'
+          ::Logger.new(STDOUT)
+        end
+      end
+
+      def_delegators :@logger, :debug, :info, :warn, :error, :fatal
+
+      def call(env)
+        info("#{env[:method]} #{env[:url].to_s}")
+        debug('request') { dump_headers(env[:request_headers])  + "\nbody: #{env[:body]}" }
+        super
+      end
+
+      def on_complete(env)
+        info('Status') { env[:status].to_s }
+        debug('response-head') { dump_headers env[:response_headers] }
+        debug('response-body') { env[:body] }
+      end
+
+      private
+
+      def dump_headers(headers)
+        headers.map { |k, v| "#{k}: #{v.inspect}" }.join("\n")
+      end
+    end
+  end
+end
+
+Faraday.register_middleware :middleware, debugger: lambda {
+  ActiveCampaign::Response::Debugger
+}

data/lib/active_campaign/response/instrumentation.rb

@@ -0,0 +1,33 @@
+module ActiveCampaign
+  module Response
+    # Public: Instruments requests using Active Support.
+    #
+    # Measures time spent only for synchronous requests.
+    #
+    # Examples
+    #
+    #   ActiveSupport::Notifications.subscribe('request.faraday') do |name, starts, ends, _, env|
+    #     url = env[:url]
+    #     http_method = env[:method].to_s.upcase
+    #     duration = ends - starts
+    #     $stderr.puts '[%s] %s %s (%.3f s)' % [url.host, http_method, url.request_uri, duration]
+    #   end
+    class Instrumentation < Faraday::Middleware
+      dependency 'active_support/notifications'
+
+      def initialize(app, options = {})
+        super(app)
+        @name = options.fetch(:name, 'request.faraday')
+      end
+
+      def call(env)
+        ActiveSupport::Notifications.instrument(@name, env) do
+          @app.call(env)
+        end
+      end
+    end
+  end
+end
+Faraday.register_middleware :middleware, instrumentation: lambda {
+  ActiveCampaign::Response::Instrumentation
+}

data/lib/active_campaign/response/json_normalizer.rb

@@ -0,0 +1,49 @@
+require 'faraday'
+require 'faraday/response'
+
+module ActiveCampaign
+  module Response
+    class JsonNormalizer < Faraday::Response::Middleware
+      def initialize(app, logger = nil)
+        super(app)
+      end
+
+      def call(environment)
+        @app.call(environment).on_complete do |env|
+          if env[:body].is_a?(Hash)
+            env[:body] = normalize(env[:body])
+          end
+        end
+      end
+
+      private
+
+        def normalize(response)
+          keys, values = keys_values(response)
+
+          if keys.all?{|key| is_numeric?(key) }
+            response[:results] = values
+            keys.each do |key|
+              response.delete(key)
+            end
+          end
+
+          response
+        end
+
+        def is_numeric?(string)
+          string.to_s.match(/\A[+-]?\d+\Z/) == nil ? false : true
+        end
+
+        def keys_values(response)
+          results = results(response)
+          [results.keys, results.values]
+        end
+
+        def results(response)
+          response.reject{|k,v| %w(result_code result_message result_output).include?(k) }
+        end
+    end
+  end
+end
+Faraday.register_middleware :response, json_normalizer: lambda { ActiveCampaign::Response::JsonNormalizer }

data/lib/active_campaign/response/mashify.rb

@@ -0,0 +1,40 @@
+require 'faraday'
+
+module ActiveCampaign
+  module Response
+
+    # Public: Converts parsed response bodies to a Hashie::Mash if they were of
+    # Hash or Array type.
+    class Mashify < Faraday::Response::Middleware
+      attr_accessor :mash_class
+
+      class << self
+        attr_accessor :mash_class
+      end
+
+      dependency do
+        require 'hashie/mash'
+        self.mash_class = ::Hashie::Mash
+      end
+
+      def initialize(app = nil, options = {})
+        super(app)
+        self.mash_class = options[:mash_class] || self.class.mash_class
+      end
+
+      def parse(body)
+        case body
+        when Hash
+          mash_class.new(body)
+        when Array
+          body.map { |item| parse(item) }
+        else
+          body
+        end
+      end
+    end
+  end
+end
+Faraday.register_middleware :response, mashify: lambda {
+  ActiveCampaign::Response::Mashify
+}