active_utils 2.2.3 → 3.0.0.pre1

data/lib/active_utils/common/currency_code.rb

@@ -1,50 +1,4 @@
-module ActiveMerchant
-  class InvalidCurrencyCodeError < StandardError
-  end
+require "active_utils/active_merchant_shim"
 
-  class CurrencyCode
-    ISO_CURRENCIES = [
-      "AED", "ALL", "AMD", "ANG", "AOA", "ARS", "AUD", "AWG", "AZN", "BAM", "BBD", "BDT", "BGN", "BHD",
-      "BND", "BOB", "BRL", "BSD", "BTN", "BWP", "BYR", "BZD", "CAD", "CHF", "CLP", "CNY", "COP", "CRC",
-      "CZK", "DKK", "DOP", "DZD", "EGP", "ETB", "EUR", "FJD", "GBP", "GEL", "GHS", "GMD", "GTQ", "GYD",
-      "HKD", "HNL", "HRK", "HUF", "IDR", "ILS", "INR", "ISK", "JEP", "JMD", "JOD", "JPY", "KES", "KGS",
-      "KHR", "KRW", "KWD", "KYD", "KZT", "LBP", "LKR", "LTL", "LVL", "MAD", "MDL", "MGA", "MKD", "MMK",
-      "MNT", "MOP", "MUR", "MVR", "MXN", "MYR", "MZN", "NAD", "NGN", "NIO", "NOK", "NPR", "NZD", "OMR",
-      "PEN", "PGK", "PHP", "PKR", "PLN", "PYG", "QAR", "RON", "RSD", "RUB", "RWF", "SAR", "SCR", "SEK",
-      "SGD", "STD", "SYP", "THB", "TND", "TRY", "TTD", "TWD", "TZS", "UAH", "UGX", "USD", "UYU", "VEF",
-      "VND", "VUV", "WST", "XAF", "XCD", "XOF", "XPF", "ZAR", "ZMW"
-    ]
-
-    NON_ISO_TO_ISO = {
-      "ARN" => "ARS",
-      "AZM" => "AZN",
-      "CHP" => "CLP",
-      "DHS" => "AED",
-      "ECD" => "XCD",
-      "GHC" => "GHS",
-      "JAD" => "JMD",
-      "JYE" => "JPY",
-      "KUD" => "KWD",
-      "MZM" => "MZN",
-      "NTD" => "TWD",
-      "NMP" => "MXN",
-      "RDD" => "DOP",
-      "RMB" => "CNY",
-      "SFR" => "CHF",
-      "SID" => "SGD",
-      "UKL" => "GBP",
-      "WON" => "KRW"
-    }
-
-    def self.standardize(code)
-      code = code.upcase unless code.nil?
-
-      return code if is_iso?(code)
-      NON_ISO_TO_ISO[code] || raise(InvalidCurrencyCodeError, "#{code} is not an ISO currency, nor can it be converted to one.")
-    end
-
-    def self.is_iso?(code)
-      ISO_CURRENCIES.include? code
-    end
-  end
-end
+ActiveUtils::Utils.deprecated(ActiveUtils::MOVED_FILE_MESSAGE)
+require "active_utils/currency_code"

data/lib/active_utils/common/error.rb

@@ -1,29 +1,4 @@
-module ActiveMerchant #:nodoc:
-  class ActiveMerchantError < StandardError #:nodoc:
-  end
+require "active_utils/active_merchant_shim"
 
-  class ConnectionError < ActiveMerchantError # :nodoc:
-  end
-
-  class RetriableConnectionError < ConnectionError # :nodoc:
-  end
-
-  class ResponseError < ActiveMerchantError # :nodoc:
-    attr_reader :response
-
-    def initialize(response, message = nil)
-      @response = response
-      @message  = message
-    end
-
-    def to_s
-      "Failed with #{response.code} #{response.message if response.respond_to?(:message)}"
-    end
-  end
-
-  class ClientCertificateError < ActiveMerchantError # :nodoc
-  end
-
-  class InvalidResponseError < ActiveMerchantError # :nodoc
-  end
-end
+ActiveUtils::Utils.deprecated(ActiveUtils::MOVED_FILE_MESSAGE)
+require "active_utils/error"

data/lib/active_utils/common/network_connection_retries.rb

@@ -1,73 +1,4 @@
-module ActiveMerchant
-  module NetworkConnectionRetries
-    DEFAULT_RETRIES = 3
-    DEFAULT_CONNECTION_ERRORS = {
-      EOFError               => "The remote server dropped the connection",
-      Errno::ECONNRESET      => "The remote server reset the connection",
-      Timeout::Error         => "The connection to the remote server timed out",
-      Errno::ETIMEDOUT       => "The connection to the remote server timed out",
-      SocketError            => "The connection to the remote server could not be established",
-      OpenSSL::SSL::SSLError => "The SSL connection to the remote server could not be established"
-    }
+require "active_utils/active_merchant_shim"
 
-    def self.included(base)
-      base.send(:attr_accessor, :retry_safe)
-    end
-
-    def retry_exceptions(options={})
-      connection_errors = DEFAULT_CONNECTION_ERRORS.merge(options[:connection_exceptions] || {})
-
-      retry_network_exceptions(options) do
-        begin
-          yield
-        rescue Errno::ECONNREFUSED => e
-          raise ActiveMerchant::RetriableConnectionError, "The remote server refused the connection"
-        rescue OpenSSL::X509::CertificateError => e
-          NetworkConnectionRetries.log(options[:logger], :error, e.message, options[:tag])
-          raise ActiveMerchant::ClientCertificateError, "The remote server did not accept the provided SSL certificate"
-        rescue Zlib::BufError => e
-          raise ActiveMerchant::InvalidResponseError, "The remote server replied with an invalid response"
-        rescue *connection_errors.keys => e
-          raise ActiveMerchant::ConnectionError, connection_errors[e.class]
-        end
-      end
-    end
-
-    private
-
-    def retry_network_exceptions(options = {})
-      initial_retries = options[:max_retries] || DEFAULT_RETRIES
-      retries = initial_retries
-      request_start = nil
-
-      begin
-        request_start = Time.now.to_f
-        result = yield
-        log_with_retry_details(options[:logger], initial_retries-retries + 1, Time.now.to_f - request_start, "success", options[:tag])
-        result
-      rescue ActiveMerchant::RetriableConnectionError => e
-        retries -= 1
-
-        log_with_retry_details(options[:logger], initial_retries-retries, Time.now.to_f - request_start, e.message, options[:tag])
-        retry unless retries.zero?
-        raise ActiveMerchant::ConnectionError, e.message
-      rescue ActiveMerchant::ConnectionError, ActiveMerchant::InvalidResponseError => e
-        retries -= 1
-        log_with_retry_details(options[:logger], initial_retries-retries, Time.now.to_f - request_start, e.message, options[:tag])
-        retry if (options[:retry_safe] || retry_safe) && !retries.zero?
-        raise
-      end
-    end
-
-    def self.log(logger, level, message, tag=nil)
-      tag ||= self.class.to_s
-      message = "[#{tag}] #{message}"
-      logger.send(level, message) if logger
-    end
-
-    private
-    def log_with_retry_details(logger, attempts, time, message, tag)
-      NetworkConnectionRetries.log(logger, :info, "connection_attempt=%d connection_request_time=%.4fs connection_msg=\"%s\"" % [attempts, time, message], tag)
-    end
-  end
-end
+ActiveUtils::Utils.deprecated(ActiveUtils::MOVED_FILE_MESSAGE)
+require "active_utils/network_connection_retries"

data/lib/active_utils/common/post_data.rb

@@ -1,24 +1,4 @@
-require 'cgi'
+require "active_utils/active_merchant_shim"
 
-module ActiveMerchant
-  class PostData < Hash
-    class_attribute :required_fields, :instance_writer => false
-    self.required_fields = []
-
-    def []=(key, value)
-      return if value.blank? && !required?(key)
-      super
-    end
-
-    def to_post_data
-      collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
-    end
-
-    alias_method :to_s, :to_post_data
-
-    private
-    def required?(key)
-      required_fields.include?(key)
-    end
-  end
-end
+ActiveUtils::Utils.deprecated(ActiveUtils::MOVED_FILE_MESSAGE)
+require "active_utils/post_data"

data/lib/active_utils/common/posts_data.rb

@@ -1,77 +1,4 @@
-module ActiveMerchant #:nodoc:
-  module PostsData  #:nodoc:
+require "active_utils/active_merchant_shim"
 
-    def self.included(base)
-      base.superclass_delegating_accessor :ssl_strict
-      base.ssl_strict = true
-
-      base.superclass_delegating_accessor :ssl_version
-      base.ssl_version = nil
-
-      base.class_attribute :retry_safe
-      base.retry_safe = false
-
-      base.superclass_delegating_accessor :open_timeout
-      base.open_timeout = 60
-
-      base.superclass_delegating_accessor :read_timeout
-      base.read_timeout = 60
-
-      base.superclass_delegating_accessor :max_retries
-      base.max_retries = Connection::MAX_RETRIES
-
-      base.superclass_delegating_accessor :logger
-      base.superclass_delegating_accessor :wiredump_device
-    end
-
-    def ssl_get(endpoint, headers={})
-      ssl_request(:get, endpoint, nil, headers)
-    end
-
-    def ssl_post(endpoint, data, headers = {})
-      ssl_request(:post, endpoint, data, headers)
-    end
-
-    def ssl_request(method, endpoint, data, headers)
-      handle_response(raw_ssl_request(method, endpoint, data, headers))
-    end
-
-    def raw_ssl_request(method, endpoint, data, headers = {})
-      logger.warn "#{self.class} using ssl_strict=false, which is insecure" if logger unless ssl_strict
-
-      connection = new_connection(endpoint)
-      connection.open_timeout = open_timeout
-      connection.read_timeout = read_timeout
-      connection.retry_safe   = retry_safe
-      connection.verify_peer  = ssl_strict
-      connection.ssl_version  = ssl_version
-      connection.logger       = logger
-      connection.max_retries  = max_retries
-      connection.tag          = self.class.name
-      connection.wiredump_device = wiredump_device
-
-      connection.pem          = @options[:pem] if @options
-      connection.pem_password = @options[:pem_password] if @options
-
-      connection.ignore_http_status = @options[:ignore_http_status] if @options
-
-      connection.request(method, data, headers)
-    end
-
-    private
-
-    def new_connection(endpoint)
-      Connection.new(endpoint)
-    end
-
-    def handle_response(response)
-      case response.code.to_i
-      when 200...300
-        response.body
-      else
-        raise ResponseError.new(response)
-      end
-    end
-
-  end
-end
+ActiveUtils::Utils.deprecated(ActiveUtils::MOVED_FILE_MESSAGE)
+require "active_utils/posts_data"

data/lib/active_utils/common/requires_parameters.rb

@@ -1,16 +1,4 @@
-module ActiveMerchant #:nodoc:
-  module RequiresParameters #:nodoc:
-    def requires!(hash, *params)
-      params.each do |param|
-        if param.is_a?(Array)
-          raise ArgumentError.new("Missing required parameter: #{param.first}") unless hash.has_key?(param.first)
+require "active_utils/active_merchant_shim"
 
-          valid_options = param[1..-1]
-          raise ArgumentError.new("Parameter: #{param.first} must be one of #{valid_options.to_sentence(:words_connector => 'or')}") unless valid_options.include?(hash[param.first])
-        else
-          raise ArgumentError.new("Missing required parameter: #{param}") unless hash.has_key?(param)
-        end
-      end
-    end
-  end
-end
+ActiveUtils::Utils.deprecated(ActiveUtils::MOVED_FILE_MESSAGE)
+require "active_utils/requires_parameters"

data/lib/active_utils/common/utils.rb

@@ -1,20 +1,4 @@
-require 'securerandom'
+require "active_utils/active_merchant_shim"
 
-module ActiveMerchant #:nodoc:
-  module Utils #:nodoc:
-    def generate_unique_id
-      SecureRandom.hex(16)
-    end
-
-    module_function :generate_unique_id
-
-    def deprecated(message)
-      warning = Kernel.caller[1] + message
-      if respond_to?(:logger) && logger.present?
-        logger.warn(warning)
-      else
-        warn(warning)
-      end
-    end
-  end
-end
+ActiveUtils::Utils.deprecated(ActiveUtils::MOVED_FILE_MESSAGE)
+require "active_utils/utils"

data/lib/active_utils/common/validateable.rb

@@ -1,81 +1,4 @@
-module ActiveMerchant #:nodoc:
-  module Validateable #:nodoc:
-    def valid?
-      errors.clear
+require "active_utils/active_merchant_shim"
 
-      before_validate if respond_to?(:before_validate, true)
-      validate if respond_to?(:validate, true)
-
-      errors.empty?
-    end
-
-    def initialize(attributes = {})
-      self.attributes = attributes
-    end
-
-    def errors
-      @errors ||= Errors.new(self)
-    end
-
-    private
-
-    def attributes=(attributes)
-      unless attributes.nil?
-        for key, value in attributes
-          send("#{key}=", value )
-        end
-      end
-    end
-
-    # This hash keeps the errors of the object
-    class Errors < HashWithIndifferentAccess
-
-      def initialize(base)
-        super() { |h, k|  h[k] = [] ; h[k] }
-        @base = base
-      end
-
-      def count
-        size
-      end
-
-      def empty?
-        all? { |k, v| v && v.empty? }
-      end
-
-      # returns a specific fields error message.
-      # if more than one error is available we will only return the first. If no error is available
-      # we return an empty string
-      def on(field)
-        self[field].to_a.first
-      end
-
-      def add(field, error)
-        self[field] << error
-      end
-
-      def add_to_base(error)
-        add(:base, error)
-      end
-
-      def each_full
-        full_messages.each { |msg| yield msg }
-      end
-
-      def full_messages
-        result = []
-
-        self.each do |key, messages|
-          next if messages.blank?
-          if key == 'base'
-            result << "#{messages.first}"
-          else
-            result << "#{key.to_s.humanize} #{messages.first}"
-          end
-        end
-
-        result
-      end
-    end
-  end
-end
+ActiveUtils::Utils.deprecated(ActiveUtils::MOVED_FILE_MESSAGE)
+require "active_utils/validateable"

data/lib/active_utils/common/version.rb

@@ -0,0 +1,4 @@
+require "active_utils/active_merchant_shim"
+
+ActiveUtils::Utils.deprecated(ActiveUtils::MOVED_FILE_MESSAGE)
+require "active_utils/version"

data/lib/active_utils/connection.rb

@@ -0,0 +1,170 @@
+require 'uri'
+require 'net/http'
+require 'net/https'
+require 'benchmark'
+
+module ActiveUtils
+  class Connection
+    include NetworkConnectionRetries
+
+    MAX_RETRIES = 3
+    OPEN_TIMEOUT = 60
+    READ_TIMEOUT = 60
+    VERIFY_PEER = true
+    CA_FILE = (File.dirname(__FILE__) + '/../../certs/cacert.pem')
+    CA_PATH = nil
+    RETRY_SAFE = false
+    RUBY_184_POST_HEADERS = { "Content-Type" => "application/x-www-form-urlencoded" }
+
+    attr_accessor :endpoint
+    attr_accessor :open_timeout
+    attr_accessor :read_timeout
+    attr_accessor :verify_peer
+    attr_accessor :ssl_version
+    attr_accessor :ca_file
+    attr_accessor :ca_path
+    attr_accessor :retry_safe
+    attr_accessor :pem
+    attr_accessor :pem_password
+    attr_accessor :wiredump_device
+    attr_accessor :logger
+    attr_accessor :tag
+    attr_accessor :ignore_http_status
+    attr_accessor :max_retries
+    attr_accessor :proxy_address
+    attr_accessor :proxy_port
+
+    def initialize(endpoint)
+      @endpoint     = endpoint.is_a?(URI) ? endpoint : URI.parse(endpoint)
+      @open_timeout = OPEN_TIMEOUT
+      @read_timeout = READ_TIMEOUT
+      @retry_safe   = RETRY_SAFE
+      @verify_peer  = VERIFY_PEER
+      @ca_file      = CA_FILE
+      @ca_path      = CA_PATH
+      @max_retries  = MAX_RETRIES
+      @ignore_http_status = false
+      @ssl_version = nil
+      @proxy_address = nil
+      @proxy_port = nil
+    end
+
+    def request(method, body, headers = {})
+      request_start = Time.now.to_f
+
+      retry_exceptions(:max_retries => max_retries, :logger => logger, :tag => tag) do
+        begin
+          info "connection_http_method=#{method.to_s.upcase} connection_uri=#{endpoint}", tag
+
+          result = nil
+
+          realtime = Benchmark.realtime do
+            result = case method
+            when :get
+              raise ArgumentError, "GET requests do not support a request body" if body
+              http.get(endpoint.request_uri, headers)
+            when :post
+              debug body
+              http.post(endpoint.request_uri, body, RUBY_184_POST_HEADERS.merge(headers))
+            when :put
+              debug body
+              http.put(endpoint.request_uri, body, headers)
+            when :delete
+              # It's kind of ambiguous whether the RFC allows bodies
+              # for DELETE requests. But Net::HTTP's delete method
+              # very unambiguously does not.
+              raise ArgumentError, "DELETE requests do not support a request body" if body
+              http.delete(endpoint.request_uri, headers)
+            else
+              raise ArgumentError, "Unsupported request method #{method.to_s.upcase}"
+            end
+          end
+
+          info "--> %d %s (%d %.4fs)" % [result.code, result.message, result.body ? result.body.length : 0, realtime], tag
+          debug result.body
+          result
+        end
+      end
+
+    ensure
+      info "connection_request_total_time=%.4fs" % [Time.now.to_f - request_start], tag
+    end
+
+    private
+    def http
+      http = Net::HTTP.new(endpoint.host, endpoint.port, proxy_address, proxy_port)
+      configure_debugging(http)
+      configure_timeouts(http)
+      configure_ssl(http)
+      configure_cert(http)
+      http
+    end
+
+    def configure_debugging(http)
+      http.set_debug_output(wiredump_device)
+    end
+
+    def configure_timeouts(http)
+      http.open_timeout = open_timeout
+      http.read_timeout = read_timeout
+    end
+
+    def configure_ssl(http)
+      return unless endpoint.scheme == "https"
+
+      http.use_ssl = true
+      http.ssl_version = ssl_version if ssl_version
+
+      if verify_peer
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        http.ca_file     = ca_file
+        http.ca_path     = ca_path
+      else
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+
+    end
+
+    def configure_cert(http)
+      return if pem.blank?
+
+      http.cert = OpenSSL::X509::Certificate.new(pem)
+
+      if pem_password
+        http.key = OpenSSL::PKey::RSA.new(pem, pem_password)
+      else
+        http.key = OpenSSL::PKey::RSA.new(pem)
+      end
+    end
+
+    def handle_response(response)
+      if @ignore_http_status then
+        return response.body
+      else
+        case response.code.to_i
+        when 200...300
+          response.body
+        else
+          raise ResponseError.new(response)
+        end
+      end
+    end
+
+    def debug(message, tag = nil)
+      log(:debug, message, tag)
+    end
+
+    def info(message, tag = nil)
+      log(:info, message, tag)
+    end
+
+    def error(message, tag = nil)
+      log(:error, message, tag)
+    end
+
+    def log(level, message, tag)
+      message = "[#{tag}] #{message}" if tag
+      logger.send(level, message) if logger
+    end
+  end
+end