recurly 2.17.5 → 4.18.0

data/lib/recurly/schema/request_caster.rb

@@ -0,0 +1,60 @@
+require "date"
+
+module Recurly
+  class Schema
+    # *Note*: This module is for internal use.
+    # The RequestCaster turns mixed data into a pure Hash
+    # so it can be serialized into JSON and used as the body of a request.
+    # This module is to be extended by the Request class.
+    module RequestCaster
+
+      # This method casts the data object (of mixed types) into a Hash ready for JSON
+      # serialization. The *schema* will default to the self's schema.
+      # You should pass in the schema where possible. This is because objects are serialized
+      # differently depending on the context in which they are being written.
+      #
+      # @example
+      #   Recurly::Requests::AccountUpdatable.cast(code: 'benjamin')
+      #   #=> {:code=>"benjamin"}
+      # @example
+      #   # If you have some mixed data, like passing in an Address, it should cast that
+      #   # address into a Hash based on the Schema defined in AccountUpdatable
+      #   address = Recurly::Resources::Address.new(city: 'New Orleans')
+      #   Recurly::Requests::AccountUpdatable.cast(account_code: 'benjamin', address: address)
+      #   #=> {:account_code=>"benjamin", :address=>{:city=>"New Orleans"}}
+      #
+      # @param data [Hash,Resource,Request] The data to transform into a JSON Hash.
+      # @param schema [Schema] The schema to use to transform the data into a JSON Hash.
+      # @return [Hash] The pure Hash ready to be serialized into JSON.
+      def cast_request(data, schema = self.schema)
+        casted = {}
+        if data.is_a?(Resource) || data.is_a?(Request)
+          data = data.attributes.reject { |_k, v| v.nil? }
+        end
+
+        data.each do |k, v|
+          schema_attr = schema.get_attribute(k)
+          norm_val = if v.respond_to?(:attributes)
+              cast_request(v, v.class.schema)
+            elsif v.is_a?(Array)
+              v.map do |elem|
+                if elem.respond_to?(:attributes)
+                  cast_request(elem, elem.class.schema)
+                else
+                  elem
+                end
+              end
+            elsif v.is_a?(Hash) && schema_attr && schema_attr.is_a?(Schema::ResourceAttribute)
+              cast_request(v, schema_attr.recurly_class.schema)
+            else
+              v
+            end
+
+          casted[k] = norm_val
+        end
+
+        casted
+      end
+    end
+  end
+end

data/lib/recurly/schema/resource_caster.rb

@@ -0,0 +1,46 @@
+require "date"
+
+module Recurly
+  class Schema
+    # The purpose of this class is to turn JSON parsed Hashes
+    # defined into Recurly ruby objects. It's to be used
+    # by the Resource as an extension.
+    module ResourceCaster
+
+      # Gives the class the ability to initialize itself
+      # given some json data.
+      #
+      # @example
+      #   Recurly::Resources::Account.cast({"code" => "mycode"})
+      #   #=> #<Recurly::Resources::Account @attributes={:code=>"mycode"}>
+      #
+      # @param attributes [Hash] A primitive Hash from JSON.parse of Recurly response.
+      # @return [Resource] the {Resource} (ruby object) representing the passed in JSON data.
+      def cast(attributes = {})
+        resource = new()
+        attributes.each do |attr_name, val|
+          schema_attr = self.schema.get_attribute(attr_name)
+
+          if schema_attr
+            val = if val.nil?
+                val
+              elsif schema_attr.is_valid?(val)
+                schema_attr.cast(val)
+              else
+                if Recurly::STRICT_MODE
+                  msg = "#{self.class}##{attr_name} does not have the right type. Value: #{val.inspect} was expected to be a #{schema_attr}"
+                  raise ArgumentError, msg
+                end
+              end
+
+            writer = "#{attr_name}="
+            resource.send(writer, val)
+          elsif Recurly::STRICT_MODE
+            raise ArgumentError, "#{resource.class.name} encountered json attribute #{attr_name.inspect}: #{val.inspect} but it's unknown to it's schema"
+          end
+        end
+        resource
+      end
+    end
+  end
+end

data/lib/recurly/schema/schema_factory.rb

@@ -0,0 +1,48 @@
+module Recurly
+  class Schema
+    # A mixin that allows a class to be treated like a recurly
+    # object. This gives the class the power to describe
+    # it's schema. It adds the *define_attribute* method
+    # and a *schema* reader.
+    module SchemaFactory
+
+      # Gets the schema for this class
+      # @return [Schema]
+      def schema
+        @schema ||= ::Recurly::Schema.new
+      end
+
+      protected
+
+      # Macro that allows this class to define it's schema and associated
+      # attribute getters and setters.
+      #
+      # @example
+      #   class Account
+      #     extend Schema::SchemaFactory
+      #     define_attribute :code, String, {:read_only=>true}
+      #   end
+      #   account = Account.new(code: "mycode")
+      #   account.schema
+      #   #=> Recurly::Schema
+      #   acount.code = "newcode" # this method protected since read_only = true
+      #   account.code
+      #   #=> "mycode"
+      def define_attribute(name, type, options = {})
+        attribute = schema.add_attribute(name, type, options)
+
+        # Define the reader
+        define_method(name) do
+          self.attributes[name]
+        end
+
+        # Define the writer
+        define_method("#{name}=") do |val|
+          self.attributes[name] = val
+        end
+
+        self
+      end
+    end
+  end
+end

data/lib/recurly/schema/schema_validator.rb

@@ -0,0 +1,144 @@
+module Recurly
+  class Schema
+    # This module is responsible for validating that the raw data
+    # passed in to *attributes* matches the schema belonging to this class.
+    # It should be mixed in to the Request class.
+    module SchemaValidator
+      # Validates the attributes and throws an error if something is wrong.
+      #
+      # @example
+      #   Recurly::Requests::PlanCreate.new(code: 'plan123').validate!
+      #   #=> {:code=>"plan123"}
+      # @example
+      #   Recurly::Requests::PlanCreate.new(code: 3.14).validate!
+      #   #=> ArgumentError: Attribute 'code' on the resource Recurly::Requests::PlanCreate is type Float but should be a String.
+      # @example
+      #   Recurly::Requests::PlanCreate.new(kode: 'plan123').validate!
+      #   #=> ArgumentError: Attribute 'kode' does not exist on request Recurly::Requests::PlanCreate. Did you mean 'code'?
+      #
+      # @raise [ArgumentError] if the attribute data does not match the schema.
+      def validate!
+        attributes.each do |attr_name, val|
+          schema_attr = schema.get_attribute(attr_name)
+          if schema_attr.nil?
+            err_msg = "Attribute '#{attr_name}' does not exist on request #{self.class.name}."
+            if did_you_mean = get_did_you_mean(schema, attr_name)
+              err_msg << " Did you mean '#{did_you_mean}'?"
+            end
+            raise ArgumentError, err_msg
+          else
+            validate_attribute!(attr_name, schema_attr, val)
+          end
+        end
+      end
+
+      # Validates an individual attribute
+      def validate_attribute!(name, schema_attr, val)
+        unless val.nil? || schema_attr.is_valid?(val)
+          # If it's safely castable, the json deserializer or server
+          # will take care of it for us
+          unless safely_castable?(val.class, schema_attr.type)
+            expected = case schema_attr
+              when Schema::ArrayAttribute
+                "Array of #{schema_attr.type}s"
+              else
+                schema_attr.type
+              end
+
+            raise ArgumentError, "Attribute '#{name}' on the resource #{self.class.name} is type #{val.class} but should be a #{expected}"
+          end
+        end
+
+        # This is the convention for a recurly object
+        if schema_attr.is_a?(Schema::ResourceAttribute) && val.is_a?(Hash)
+          # Using send because the initializer may be private
+          instance = schema_attr.recurly_class.send(:new, val)
+          instance.validate!
+        end
+      end
+
+      # Gets the closest term to the misspelled attribute
+      def get_did_you_mean(schema, misspelled_attr)
+        closest = schema.attributes.keys.sort_by do |v|
+          levenshtein_distance(v, misspelled_attr)
+        end.first
+
+        if closest && levenshtein_distance(closest, misspelled_attr) <= 4
+          closest
+        end
+      end
+
+      private
+
+      def safely_castable?(from_type, to_type)
+        # TODO we can drop this switch when 2.3 support is dropped
+        int_class = if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.4.0")
+            :Integer
+          else
+            :Fixnum
+          end
+        int_class = Kernel.const_get(int_class)
+
+        case [from_type, to_type]
+        when [Symbol, String]
+          true
+        when [int_class, Float]
+          true
+        else
+          false
+        end
+      end
+
+      # This code is copied directly from the did_you mean gem which is based
+      # directly on the Text gem implementation.
+      #
+      # did_you_mean: Copyright (c) 2014-2016 Yuki Nishijima.
+      # Text:         Copyright (c) 2006-2013 Paul Battley, Michael Neumann, Tim Fletcher.
+      #
+      # Returns a value representing the "cost" of transforming str1 into str2
+      def levenshtein_distance(str1, str2)
+        str1 = str1.to_s unless str1.is_a? String
+        str2 = str2.to_s unless str2.is_a? String
+        n = str1.length
+        m = str2.length
+        return m if n.zero?
+        return n if m.zero?
+
+        d = (0..m).to_a
+        x = nil
+
+        # to avoid duplicating an enumerable object, create it outside of the loop
+        str2_codepoints = str2.codepoints
+
+        str1.each_codepoint.with_index(1) do |char1, i|
+          j = 0
+          while j < m
+            cost = (char1 == str2_codepoints[j]) ? 0 : 1
+            x = min3(
+              d[j + 1] + 1, # insertion
+              i + 1,      # deletion
+              d[j] + cost # substitution
+            )
+            d[j] = i
+            i = x
+
+            j += 1
+          end
+          d[m] = x
+        end
+
+        x
+      end
+
+      def min3(a, b, c)
+        if a < b && a < c
+          a
+        elsif b < c
+          b
+        else
+          c
+        end
+      end
+    end
+  end
+end

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   = 5
-    PRE     = nil
-
-    VERSION = [MAJOR, MINOR, PATCH, PRE].compact.join('.').freeze
-
-    class << self
-      def inspect
-        VERSION.dup
-      end
-      alias to_s inspect
-    end
-  end
+  VERSION = "4.18.0"
 end

data/lib/recurly.rb

@@ -1,141 +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/note'
-  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