recurly 2.19.12 → 3.0.0.beta.1

data/lib/recurly/schema/schema_validator.rb

@@ -0,0 +1,125 @@
+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}'?"
+              raise ArgumentError, err_msg
+            end
+          elsif schema_attr.read_only?
+            raise ArgumentError, "Attribute '#{attr_name}' on resource #{self.class.name} is not writeable"
+          else
+            validate_attribute!(schema_attr, val)
+          end
+        end
+      end
+
+      # Validates an individual attribute
+      def validate_attribute!(schema_attr, val)
+        if !schema_attr.type.is_a?(Symbol) && val.class != schema_attr.type
+          expected = case schema_attr.type
+                     when Array
+                       "Array of #{schema_attr.type.item_type}s"
+                     else
+                       schema_attr.type
+                     end
+
+          raise ArgumentError, "Attribute '#{schema_attr.name}' on the resource #{self.class.name} is type #{val.class} but should be a #{expected}"
+        end
+
+        # This is the convention for a recurly object
+        if schema_attr.type.is_a?(Symbol) && val.is_a?(Hash)
+          klazz = Schema.get_recurly_class(schema_attr.type)
+          # Using send because the initializer may be private
+          instance = klazz.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.map(&:name).sort_by do |v|
+          levenshtein_distance(v, misspelled_attr)
+        end.first
+
+        if closest && levenshtein_distance(closest, misspelled_attr) <= 4
+          closest
+        end
+      end
+
+      private
+
+      # 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,114 @@
+module Recurly
+  # The class responsible for describing a schema.
+  # This is used for requests and resources.
+  class Schema
+    # The attributes in the schema
+    # @return [Array<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 [Hash] The attribute options. See {Attribute#options}
+    def add_attribute(name, type, options)
+      attribute = Attribute.new(name, type, options)
+      @attributes.push(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)
+      name = name.to_s
+      @attributes.find { |a| a.name.to_s == name }
+    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 Requests.const_defined?(type)
+        Requests.const_get(type)
+      elsif Resources.const_defined?(type)
+        Resources.const_get(type)
+      else
+        raise ArgumentError, "Recurly type '#{type}' is unknown"
+      end
+    end
+
+    # Describes a list attribute type
+    class List
+      # The type of the elements of the list
+      # @return [Symbol]
+      attr_accessor :item_type
+
+      def initialize(item_type)
+        @item_type = item_type
+      end
+
+      def to_s
+        "List<#{item_type}>"
+      end
+    end
+
+    # Describes and attribute for a schema.
+    class Attribute
+      # The name of the attribute.
+      # @return [Symbol]
+      attr_accessor :name
+
+      # 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
+      # @return [Class,Symbol]
+      attr_accessor :type
+
+      # Options for the attribute.
+      # @return [Hash]
+      attr_accessor :options
+
+      # The description of the attribute for documentation.
+      # @return [String]
+      attr_accessor :description
+
+      def initialize(name, type, options={}, description=nil)
+        @name = name
+        @type = type
+        @options = options
+        @description = description
+      end
+
+      def read_only?
+        @options.fetch(:read_only, false)
+      end
+
+      def recurly_class
+        Schema.get_recurly_class(type == Array ? options[:item_type] : type)
+      end
+    end
+
+    private_constant :List
+    private_constant :Attribute
+  end
+
+
+  require_relative './schema/schema_factory'
+  require_relative './schema/schema_validator'
+  require_relative './schema/json_deserializer'
+  require_relative './schema/request_caster'
+end

data/lib/recurly/version.rb

@@ -1,12 +1,3 @@
 module Recurly
-  module Version
-    VERSION = "2.19.12"
-
-    class << self
-      def inspect
-        VERSION.dup
-      end
-      alias to_s inspect
-    end
-  end
+  VERSION = "3.0.0.beta.1"
 end

data/lib/recurly.rb

@@ -1,169 +1,16 @@
-# 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/gateway_attribute'
-  require 'recurly/billing_info'
-  require 'recurly/custom_field'
-  require 'recurly/account_acquisition'
-  require 'recurly/account'
-  require 'recurly/account_balance'
-  require 'recurly/add_on'
-  require 'recurly/address'
-  require 'recurly/business_entity'
-  require 'recurly/tax_detail'
-  require 'recurly/tax_type'
-  require 'recurly/juris_detail'
-  require 'recurly/adjustment'
-  require 'recurly/coupon'
-  require 'recurly/credit_payment'
-  require 'recurly/customer_permission'
-  require 'recurly/entitlement'
-  require 'recurly/external_account'
-  require 'recurly/external_charge'
-  require 'recurly/external_invoice'
-  require 'recurly/external_product'
-  require 'recurly/external_product_reference'
-  require 'recurly/external_payment_phase'
-  require 'recurly/external_subscription'
-  require 'recurly/helper'
-  require 'recurly/invoice'
-  require 'recurly/invoice_collection'
-  require 'recurly/item'
-  require 'recurly/js'
-  require 'recurly/money'
-  require 'recurly/measured_unit'
-  require 'recurly/note'
-  require 'recurly/plan'
-  require 'recurly/plan_ramp_interval'
-  require 'recurly/redemption'
-  require 'recurly/shipping_fee'
-  require 'recurly/shipping_method'
-  require 'recurly/subscription'
-  require 'recurly/subscription_add_on'
-  require 'recurly/subscription_ramp_interval'
-  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'
-  require 'recurly/verify'
-  require 'recurly/tier'
-  require 'recurly/dunning_campaign'
-  require 'recurly/dunning_cycle'
-  require 'recurly/invoice_template'
-  require 'recurly/percentage_tier'
-  require 'recurly/currency_percentage_tier'
-  require 'recurly/sub_add_on_percentage_tier'
-  require 'recurly/custom_field_definition'
-  require 'recurly/general_ledger_account'
-  require 'recurly/performance_obligation'
-
-  @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
-
-    # @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
+require "recurly/version"
+require "recurly/schema"
+require "recurly/request"
+require "recurly/resource"
+require "recurly/pager"
+# Include all request files
+resources = File.join(File.dirname(__FILE__), 'recurly', 'requests', '*.rb')
+Dir.glob(resources, &method(:require))
+# Include all resource files
+resources = File.join(File.dirname(__FILE__), 'recurly', 'resources', '*.rb')
+Dir.glob(resources, &method(:require))
+require "recurly/errors"
+require "recurly/client"
 
-      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
-  end
+module Recurly
 end

data/recurly.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'recurly/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "recurly"
+  spec.version       = Recurly::VERSION
+  spec.authors       = ["Recurly"]
+  spec.email         = ["support@recurly.com"]
+
+  spec.summary       = "The ruby client for Recurly's Partner API"
+  spec.description   = "The ruby client for Recurly's Partner API"
+  spec.homepage      = "https://partner-docs.recurly.com"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  # spec.bindir        = "exe"
+  # spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "faraday", "~> 0.13"
+
+  spec.add_development_dependency "bundler", "~> 1.14"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "yard", "~> 0.9"
+  spec.add_development_dependency "pry", "~> 0.10"
+  spec.add_development_dependency "simplecov", "~> 0.16"
+end

data/scripts/build

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+
+bundle install --binstubs --quiet
+./bin/yard --quiet

data/scripts/clean

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+
+rm -f ./lib/recurly/resources/*
+rm -f ./lib/recurly/requests/*
+rm -f ./lib/recurly/errors/api_errors.rb
+rm -f ./lib/recurly/client/operations.rb

data/scripts/test

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+
+./bin/rspec