recurly 2.17.0 → 3.14.0

data/lib/recurly/schema.rb

@@ -0,0 +1,156 @@
+module Recurly
+  # The class responsible for describing a schema.
+  # This is used for requests and resources.
+  class Schema
+    # The attributes in the schema
+    # @return [Hash<String,Attribute>]
+    attr_reader :attributes
+
+    def initialize
+      @attributes = {}
+    end
+
+    # Adds an attribute to the schema definition
+    #
+    # @param name [Symbol] The name of the attribute
+    # @param type [Class,Symbol] The type of the attribute. Use capitalized symbol for Recurly class. Example: :Account.
+    # @param options [Schema::Attribute] The created and registered attribute object.
+    def add_attribute(name, type, options)
+      attribute = Attribute.build(type, options)
+      @attributes[name.to_s] = attribute
+      attribute
+    end
+
+    # Gets an attribute from this schema given a name
+    #
+    # @param name [String,Symbol] The name/key of the attribute
+    # @return [Attribute,nil] The found Attribute. nil if not found.
+    def get_attribute(name)
+      @attributes[name.to_s]
+    end
+
+    # Gets a recurly class given a symbol name.
+    #
+    # @example
+    #   Schema.get_recurly_class(:Account)
+    #   #=> Recurly::Resources::Account
+    #
+    # @param type [Symbol] The name of the class you wish to find
+    # @return [Request,Resource]
+    # @raise ArgumentError If class can't be found.
+    def self.get_recurly_class(type)
+      raise ArgumentError, "#{type.inspect} must be a symbol but is a #{type.class}" unless type.is_a?(Symbol)
+
+      if type == :Address
+        Recurly::Resources::Address
+      elsif Recurly::Requests.const_defined?(type, false)
+        Recurly::Requests.const_get(type, false)
+      elsif Recurly::Resources.const_defined?(type, false)
+        Recurly::Resources.const_get(type, false)
+      else
+        raise ArgumentError, "Recurly type '#{type}' is unknown"
+      end
+    end
+
+    class Attribute
+      # The type of the attribute. Might be a class like `DateTime`
+      # or could be a Recurly object. In this case a symbol should be used.
+      # Example: :Account. To get the Recurly type use #recurly_class
+      # @return [Class,Symbol]
+      attr_reader :type
+
+      PRIMITIVE_TYPES = [
+        String,
+        Integer,
+        Float,
+        Hash,
+      ].freeze
+
+      def self.build(type, options = {})
+        if PRIMITIVE_TYPES.include? type
+          PrimitiveAttribute.new(type)
+        elsif type == :Boolean
+          BooleanAttribute.new
+        elsif type == DateTime
+          DateTimeAttribute.new
+        elsif type.is_a? Symbol
+          ResourceAttribute.new(type)
+        elsif type == Array
+          item_attr = build(options[:item_type])
+          ArrayAttribute.new(item_attr)
+        else
+          throw ArgumentError
+        end
+      end
+
+      def initialize(type = nil)
+        @type = type
+      end
+
+      def cast(value)
+        value
+      end
+
+      def recurly_class
+        @recurly_class ||= Schema.get_recurly_class(type)
+      end
+    end
+
+    class PrimitiveAttribute < Attribute
+      def is_valid?(value)
+        value.is_a? self.type
+      end
+    end
+
+    class BooleanAttribute < Attribute
+      def is_valid?(value)
+        [true, false].include? value
+      end
+    end
+
+    class DateTimeAttribute < Attribute
+      def is_valid?(value)
+        value.is_a?(String) || value.is_a?(DateTime)
+      end
+
+      def cast(value)
+        if value.is_a?(DateTime)
+          value
+        else
+          DateTime.parse(value)
+        end
+      end
+
+      def type
+        DateTime
+      end
+    end
+
+    class ResourceAttribute < Attribute
+      def is_valid?(value)
+        value.is_a? Hash
+      end
+
+      def cast(value)
+        self.recurly_class.cast(value)
+      end
+    end
+
+    class ArrayAttribute < Attribute
+      def is_valid?(value)
+        value.is_a? Array
+      end
+
+      def cast(value)
+        value.map do |v|
+          self.type.cast(v)
+        end
+      end
+    end
+  end
+
+  require_relative "./schema/schema_factory"
+  require_relative "./schema/schema_validator"
+  require_relative "./schema/resource_caster"
+  require_relative "./schema/request_caster"
+end

data/lib/recurly/version.rb

@@ -1,17 +1,3 @@
 module Recurly
-  module Version
-    MAJOR   = 2
-    MINOR   = 17
-    PATCH   = 0
-    PRE     = nil
-
-    VERSION = [MAJOR, MINOR, PATCH, PRE].compact.join('.').freeze
-
-    class << self
-      def inspect
-        VERSION.dup
-      end
-      alias to_s inspect
-    end
-  end
+  VERSION = "3.14.0"
 end

data/lib/recurly.rb

@@ -1,140 +1,18 @@
-# Recurly is a Ruby client for Recurly's REST API.
-module Recurly
-  require 'recurly/error'
-  require 'recurly/helper'
-  require 'recurly/api'
-  require 'recurly/resource'
-  require 'recurly/shipping_address'
-  require 'recurly/billing_info'
-  require 'recurly/custom_field'
-  require 'recurly/account'
-  require 'recurly/account_balance'
-  require 'recurly/add_on'
-  require 'recurly/address'
-  require 'recurly/tax_detail'
-  require 'recurly/tax_type'
-  require 'recurly/juris_detail'
-  require 'recurly/adjustment'
-  require 'recurly/coupon'
-  require 'recurly/credit_payment'
-  require 'recurly/helper'
-  require 'recurly/invoice'
-  require 'recurly/invoice_collection'
-  require 'recurly/js'
-  require 'recurly/money'
-  require 'recurly/measured_unit'
-  require 'recurly/plan'
-  require 'recurly/redemption'
-  require 'recurly/subscription'
-  require 'recurly/subscription_add_on'
-  require 'recurly/transaction'
-  require 'recurly/usage'
-  require 'recurly/version'
-  require 'recurly/xml'
-  require 'recurly/delivery'
-  require 'recurly/gift_card'
-  require 'recurly/purchase'
-  require 'recurly/webhook'
-
-  @subdomain = nil
-
-  # This exception is raised if Recurly has not been configured.
-  class ConfigurationError < Error
-  end
-
-  class << self
-    # Set a config based on current thread context.
-    # Any default set will say in effect unless overwritten in the config_params.
-    # Call this method with out any arguments to have it unset the thread context config values.
-    # @param config_params - Hash with the following keys: subdomain, api_key, default_currency
-    def config(config_params = nil)
-      Thread.current[:recurly_config] = config_params
-    end
-
-    # @return [String] A subdomain.
-    def subdomain
-      if Thread.current[:recurly_config] && Thread.current[:recurly_config][:subdomain]
-        return Thread.current[:recurly_config][:subdomain]
-      end
-      @subdomain || 'api'
-    end
-    attr_writer :subdomain
-
-    # @return [String] An API key.
-    # @raise [ConfigurationError] If not configured.
-    def api_key
-      if Thread.current[:recurly_config] && Thread.current[:recurly_config][:api_key]
-        return Thread.current[:recurly_config][:api_key]
-      end
-
-      defined? @api_key and @api_key or raise(
-        ConfigurationError, "Recurly.api_key not configured"
-      )
-    end
-    attr_writer :api_key
+require "recurly/version"
+require "recurly/schema"
+require "recurly/request"
+require "recurly/resource"
+require "recurly/pager"
+require "recurly/requests"
+require "recurly/resources"
+require "recurly/http"
+require "recurly/errors"
+require "recurly/connection_pool"
+require "recurly/client"
 
-    # @return [String, nil] A default currency.
-    def default_currency
-      if Thread.current[:recurly_config] &&  Thread.current[:recurly_config][:default_currency]
-        return Thread.current[:recurly_config][:default_currency]
-      end
-
-      return  @default_currency if defined? @default_currency
-      @default_currency = 'USD'
-    end
-    attr_writer :default_currency
-
-    # @return [JS] The Recurly.js module.
-    def js
-      JS
-    end
-
-    # Assigns a logger to log requests/responses and more.
-    # The logger can only be set if the environment variable
-    # `RECURLY_INSECURE_DEBUG` equals `true`.
-    #
-    # @return [Logger, nil]
-    # @example
-    #   require 'logger'
-    #   Recurly.logger = Logger.new STDOUT
-    # @example Rails applications automatically log to the Rails log:
-    #   Recurly.logger = Rails.logger
-    # @example Turn off logging entirely:
-    #   Recurly.logger = nil # Or Recurly.logger = Logger.new nil
-    attr_accessor :logger
-
-    def logger=(logger)
-      if ENV['RECURLY_INSECURE_DEBUG'].to_s.downcase == 'true'
-        @logger = logger
-        puts <<-MSG
-        [WARNING] Recurly logger enabled. The logger has the potential to leak
-        PII and should never be used in production environments.
-        MSG
-      else
-        puts <<-MSG
-        [WARNING] Recurly logger has been disabled. If you wish to use it,
-        only do so in a non-production environment and make sure
-        the `RECURLY_INSECURE_DEBUG` environment variable is set to `true`.
-        MSG
-      end
-    end
-
-    # Convenience logging method includes a Logger#progname dynamically.
-    # @return [true, nil]
-    def log level, message
-      logger.send(level, name) { message }
-    end
-
-    if RUBY_VERSION <= "1.9.0"
-      def const_defined? sym, inherit = false
-        raise ArgumentError, "inherit must be false" if inherit
-        super sym
-      end
-
-      def const_get sym, inherit = false
-        raise ArgumentError, "inherit must be false" if inherit
-        super sym
-      end
-    end
+module Recurly
+  STRICT_MODE = ENV["RECURLY_STRICT_MODE"] && ENV["RECURLY_STRICT_MODE"].downcase == "true"
+  if STRICT_MODE
+    puts "[Recurly] [WARNING] STRICT_MODE enabled. This should only be used for testing purposes."
   end
 end