active_campaign 0.0.12 → 0.1.1

data/lib/active_campaign/param_validation.rb

@@ -1,12 +0,0 @@
-module ActiveCampaign
-  module ParamValidation
-    def filter_params(allowed_keys = [], params = {})
-      params.keys.select do |k,v|
-        allowed_keys.each do |param|
-          params.include?(k) ||
-          param.match(k)
-        end
-      end
-    end
-  end
-end

data/lib/active_campaign/request.rb

@@ -1,84 +0,0 @@
-require 'multi_json'
-
-module ActiveCampaign
-  module Request
-
-    def delete(api_method, options={})
-      request(:delete, api_method, options).body
-    end
-
-    def get(api_method, options={})
-      request(:get, api_method, options).body
-    end
-
-    def patch(api_method, options={})
-      request(:patch, api_method, options).body
-    end
-
-    def post(api_method, options={})
-      request(:post, api_method, options).body
-    rescue => e
-      puts e, e.backtrace
-    end
-
-    def put(api_method, options={})
-      request(:put, api_method, options).body
-    end
-
-    private
-
-      # Executes the request, checking if it was successful
-      #
-      # @return [Boolean] True on success, false otherwise
-      def boolean_from_response(method, api_method, options={})
-       request(method, api_method, options).status == 204
-      rescue ActiveCampaign::NotFound
-        false
-      end
-
-      def path(api_method)
-        "#{api_path}?#{url_params(api_method).map{|k,v| "#{k}=#{v}" }.join('&')}"
-      end
-
-      def url_params(api_method)
-        {
-          api_key: api_key,
-          api_action: api_method,
-          api_output: api_output,
-        }
-      end
-
-      def request(method, api_method, options={})
-
-        force_urlencoded = options.delete(:force_urlencoded) || false
-        url = options.delete(:endpoint) || api_endpoint
-
-        conn_options = {
-          :force_urlencoded => force_urlencoded,
-          :url => url
-        }
-
-        response = connection(conn_options).send(method) do |request|
-          case method
-          when :get, :delete, :head
-            options.reverse_merge!(url_params(api_method))
-            request.url(api_path, options)
-          when :patch, :post, :put
-            request.url(api_path, url_params(api_method))
-            if force_urlencoded
-              request.body = options unless options.empty?
-            else
-              request.body = MultiJson.dump(options) unless options.empty?
-            end
-          end
-
-          if ActiveCampaign.request_host
-            request.headers['Host'] = ActiveCampaign.request_host
-          end
-
-        end
-        response
-      end
-
-  end
-end

data/lib/faraday/response/body_logger.rb

@@ -1,37 +0,0 @@
-require 'faraday'
-require 'forwardable'
-
-module Faraday
-  class Response::BodyLogger < 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
-Faraday.register_middleware :response, body_logger: lambda { Faraday::Response::BodyLogger }

data/lib/faraday/response/json_normalizer.rb

@@ -1,46 +0,0 @@
-require 'faraday'
-require 'faraday/response'
-
-module Faraday
-  class Response::JsonNormalizer < 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
-Faraday.register_middleware :response, json_normalizer: lambda { Faraday::Response::JsonNormalizer }

data/lib/faraday/response/raise_active_campaign_error.rb

@@ -1,25 +0,0 @@
-require 'faraday'
-require 'multi_json'
-
-# @api private
-module Faraday
-  class Response::RaiseActiveCampaignError < Response::Middleware
-    ERROR_MAP = {
-      400 => ActiveCampaign::BadRequest,
-      401 => ActiveCampaign::Unauthorized,
-      403 => ActiveCampaign::Forbidden,
-      404 => ActiveCampaign::NotFound,
-      406 => ActiveCampaign::NotAcceptable,
-      422 => ActiveCampaign::UnprocessableEntity,
-      500 => ActiveCampaign::InternalServerError,
-      501 => ActiveCampaign::NotImplemented,
-      502 => ActiveCampaign::BadGateway,
-      503 => ActiveCampaign::ServiceUnavailable
-    }
-
-    def on_complete(response)
-      key = response[:status].to_i
-      raise ERROR_MAP[key].new(response) if ERROR_MAP.has_key? key
-    end
-  end
-end