recurly 2.19.7 → 3.0.0.beta.1

data/lib/recurly/gift_card.rb

@@ -1,85 +0,0 @@
-module Recurly
-  class GiftCard < Resource
-    # @return [Invoice, nil]
-    belongs_to :invoice
-
-    # @return [Account, nil] The Account belonging to the gifter
-    belongs_to :gifter_account, class_name: :Account, readonly: false
-
-    # @return [Account, nil] The Account belonging to the recipient of the gift
-    belongs_to :recipient_account, class_name: :Account, readonly: false
-
-    # @return [Delivery, nil] Delivery information of the recipient.
-    has_one :delivery, class_name: :Delivery, readonly: false
-
-    # @return [Invoice, nil] The credit invoice for the gift card redemption.
-    has_one :redemption_invoice, class_name: :Invoice, readonly: true
-
-    # @return [Invoice, nil] The charge invoice for the gift card redemption.
-    has_one :purchase_invoice, class_name: :Invoice, readonly: true
-
-    # @return [BillingInfo, nil]
-    has_one :billing_info, class_name: :BillingInfo, readonly: false
-
-    define_attribute_methods %w(
-      balance_in_cents
-      currency
-      created_at
-      delivered_at
-      id
-      product_code
-      redeemed_at
-      redemption_code
-      unit_amount_in_cents
-      updated_at
-      canceled_at
-      gifter_account_code
-      recipient_account_code
-      invoice_number
-    )
-    alias to_param id
-
-    # Preview a GiftCard given some attributes
-    #
-    # @param [Hash] attributes for the gift card
-    # @return [GiftCard] The resulting preview GiftCard
-    def self.preview(attributes = {})
-      new(attributes) { |record| record.preview }
-    end
-
-    # Preview the GiftCard. Runs and validates the GiftCard but
-    # does not persist it. Errors are applied to the GiftCard if there
-    # are any errors.
-    def preview
-      clear_errors
-      @response = API.send(:post, "#{path}/preview", to_xml)
-      reload response
-    rescue API::UnprocessableEntity => e
-      apply_errors e
-    end
-
-    # Redeem this GiftCard on the given account.
-    #
-    # @param [String] Recipient's account code
-    def redeem(recipient_account_code)
-      clear_errors
-      xml = <<-XML
-        <recipient_account>
-            <account_code>#{recipient_account_code}</account_code>
-        </recipient_account>
-      XML
-      @response = API.send(:post, "#{self.class.collection_path}/#{redemption_code}/redeem", xml)
-      reload response
-    rescue API::UnprocessableEntity => e
-      apply_errors e
-    end
-
-    private
-
-    def xml_keys
-      keys = super
-      keys << 'redemption_code' if redemption_code? && !redemption_code_changed?
-      keys.sort
-    end
-  end
-end

data/lib/recurly/helper.rb

@@ -1,51 +0,0 @@
-module Recurly
-  module Helper
-    def camelize underscored_word
-      underscored_word.to_s.gsub(/(?:^|_)(.)/) { $1.upcase }
-    end
-
-    def classify table_name
-      camelize singularize(table_name.to_s.sub(/.*\./, ''))
-    end
-
-    def demodulize class_name_in_module
-      class_name_in_module.to_s.sub(/^.*::/, '')
-    end
-
-    def pluralize word
-      word.to_s.sub(/([^s])$/, '\1s')
-    end
-
-    def singularize word
-      word = word.to_s
-      return word if word.end_with?('address')
-      return "shipping_address" if word == "shipping_addresses"
-      word.sub(/s$/, '').sub(/ie$/, 'y')
-    end
-
-    def underscore camel_cased_word
-      word = camel_cased_word.to_s.dup
-      word.gsub!(/::/, '/')
-      word.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-      word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
-      word.tr! "-", "_"
-      word.downcase!
-      word
-    end
-
-    def hash_with_indifferent_read_access base = {}
-      indifferent = Hash.new { |hash, key| hash[key.to_s] if key.is_a? Symbol }
-      base.each_pair { |key, value| indifferent[key.to_s] = value }
-      indifferent
-    end
-
-    def stringify_keys! hash
-      hash.keys.each do |key|
-        stringify_keys! hash[key] if hash[key].is_a? Hash
-        hash[key.to_s] = hash.delete key if key.is_a? Symbol
-      end
-    end
-
-    extend self
-  end
-end

data/lib/recurly/invoice.rb

@@ -1,322 +0,0 @@
-module Recurly
-  # Invoices are created through account objects.
-  #
-  # Recurly Documentation: https://dev.recurly.com/docs/list-invoices
-  #
-  # @example
-  #   account = Account.find(account_code)
-  #   account.invoice!
-  class Invoice < Resource
-    # @macro [attach] scope
-    #   @scope class
-    #   @return [Pager<Invoice>] A pager that yields +$1+ invoices.
-    scope :pending,   :state => :pending
-    scope :paid,      :state => :paid
-    scope :failed,    :state => :failed
-    scope :past_due,  :state => :past_due
-
-    # These are deprecated as the states were renamed
-    scope :open,      :state => :pending
-    scope :collected, :state => :paid
-
-    # @return [Account]
-    belongs_to :account
-
-    # @return [BusinessEntity]
-    belongs_to :business_entity
-
-    # @return [Pager<Subscription>, []]
-    has_many :subscriptions
-
-    # This will only be present if the invoice has > 500 line items
-    # @return [Pager<Adjustment>, []]
-    has_many :all_line_items, class_name: :Adjustment
-
-    # This will only be present if the invoice has > 500 transactions
-    # @return [Pager<Transaction>, []]
-    has_many :all_transactions, class_name: :Transaction
-
-    # @return [Pager<Redemption>, []]
-    has_many :redemptions
-
-    # @return [ShippingAddress, nil]
-    has_one :shipping_address, class_name: :ShippingAddress, readonly: true
-
-    # @return [Pager<Invoice>, []]
-    has_many :credit_invoices, class_name: :Invoice
-
-    # @return [[CreditPayment]]
-    has_many :credit_payments, class_name: :CreditPayment, readonly: true
-
-    # @return [Pager<Invoice>, []]
-    has_many :original_invoices, class_name: :Invoice, readonly: true
-
-    # @return [Invoice, nil]
-    has_one :original_invoice, class_name: :Invoice, readonly: true
-
-    # @return [BillingInfo, nil]
-    has_one :billing_info, class_name: :BillingInfo, readonly: true
-
-    # Returns the first redemption in the Invoice's redemptions.
-    # This was placed here for backwards compatibility when we went from
-    # having a single redemption per invoice to multiple redemptions per invoice.
-    #
-    # @deprecated Use {#redemptions} and find the redemption you want.
-    def redemption
-      redemptions.first
-    end
-
-    # @return [String] The invoice number with the prefix (if there is one)
-    def invoice_number_with_prefix
-      "#{invoice_number_prefix}#{invoice_number}"
-    end
-
-    define_attribute_methods %w(
-      uuid
-      state
-      invoice_number
-      invoice_number_prefix
-      po_number
-      vat_number
-      subtotal_in_cents
-      tax_in_cents
-      tax_type
-      tax_region
-      tax_rate
-      total_in_cents
-      currency
-      created_at
-      updated_at
-      closed_at
-      amount_remaining_in_cents
-      line_items
-      transactions
-      terms_and_conditions
-      vat_reverse_charge_notes
-      customer_notes
-      address
-      net_terms
-      collection_method
-      tax_types
-      refund_tax_date
-      refund_geo_code
-      subtotal_before_discount_in_cents
-      attempt_next_collection_at
-      recovery_reason
-      discount_in_cents
-      balance_in_cents
-      due_on
-      type
-      origin
-      credit_customer_notes
-      refund_method
-      subscription_id
-      subscription_ids
-      dunning_events_count
-      final_dunning_event
-      gateway_code
-      surcharge_in_cents
-      tax_details
-      billing_info_uuid
-      dunning_campaign_id
-      refundable_total_in_cents
-      used_tax_service
-      business_entity_id
-    )
-    alias to_param invoice_number_with_prefix
-
-    def self.to_xml(attrs)
-      invoice = new attrs
-      invoice.to_xml
-    end
-
-    # Marks an invoice as paid successfully.
-    #
-    # @return [true, false] +true+ when successful, +false+ when unable to
-    #   (e.g., the invoice is no longer open).
-    def mark_successful
-      return false unless link? :mark_successful
-      reload follow_link :mark_successful
-      true
-    end
-
-    # Marks an invoice as failing collection.
-    # Returns a new {InvoiceCollection} and does not
-    # reload this invoice.
-    #
-    # @return [InvoiceCollection, false] InvoiceCollection when successful, +false+ when unable to
-    #   (e.g., the invoice is no longer open).
-    def mark_failed
-      return false unless link? :mark_failed
-      InvoiceCollection.from_response follow_link(:mark_failed)
-    rescue Recurly::API::UnprocessableEntity => e
-      raise Invalid, e.message
-    end
-
-    # Initiate a collection attempt on an invoice.
-    #
-    # @example
-    #   # Optionally set transaction type
-    #   invoice.force_collect(transaction_type: 'moto')
-    #
-    # @param options [Hash] Optional set of details to send to collect endpoint.
-    # @return [true, false] +true+ when successful, +false+ when unable to
-    #   (e.g., the invoice is no longer open).
-    def force_collect(options = {})
-      return false unless link? :force_collect
-      http_opts = {}
-      if body = force_collect_xml(options)
-        http_opts[:body] = body
-      end
-      reload follow_link(:force_collect, http_opts)
-      true
-    end
-
-    # Voids the invoice.
-    #
-    # @return [true, false] +true+ when successful, +false+ when unable to
-    #   (e.g., the invoice is no longer open).
-    def void
-      return false unless link? :void
-      reload follow_link :void
-      true
-    end
-
-    # Applies the open credit balance on the account to the invoice balance.
-    #
-    # @return [true, false] +true+ when successful, +false+ when unable to
-    #   (e.g., the invoice is no longer collectible).
-    def apply_credit_balance
-      return false unless link? :apply_credit_balance
-      reload follow_link :apply_credit_balance
-      true
-    end
-
-    # Posts an offline payment on this invoice
-    #
-    # @return [Transaction]
-    # @raise [Error] If the transaction fails.
-    def enter_offline_payment(attrs={})
-      Transaction.from_response API.post("#{uri}/transactions", attrs.empty? ? nil : Transaction.to_xml(attrs))
-    rescue Recurly::API::UnprocessableEntity => e
-      raise Invalid, e.message
-    end
-
-    # Fetches the pdf for this invoice
-    def pdf
-      self.class.find(to_param, format: 'pdf')
-    end
-
-    # Refunds specific line items on the invoice.
-    #
-    # @return [Invoice, false] Invoice if successful, false if the invoice isn't
-    # refundable.
-    # @raise [Error] If the refund fails.
-    # @param line_items [Array, nil] An array of line items to refund.
-    # @param refund_method ["credit_first", "transaction_first", "all_transaction", "all_credit"] The method used to refund.
-    # @param external_refund [true, false] Designates that the refund transactions created are manual.
-    # @param credit_customer_notes [String] Adds notes to refund credit invoice.
-    # @param payment_method [String] Creates the manual transactions with this payment method. Allowed if *external_refund* is true.
-    # @param description [String] Sets this value as the *transaction_note* on the manual transactions created. Allowed if *external_refund* is true.
-    # @param refunded_at [DateTime] Sets this value as the *collected_at* on the manual transactions created. Allowed if *external_refund* is true.
-    def refund(line_items = nil, refund_method = 'credit_first', options = {})
-      return false unless link? :refund
-      self.class.from_response(
-        follow_link :refund, :body => refund_line_items_to_xml(line_items, refund_method, options)
-      )
-    rescue Recurly::API::UnprocessableEntity => e
-      Transaction::Error.validate! e, (self if is_a?(Transaction))
-      raise
-    end
-
-    # Refunds the invoice for a specific amount.
-    #
-    # @return [Invoice, false] Invoice if successful, false if the invoice isn't
-    # refundable.
-    # @raise [Error] If the refund fails.
-    # @param amount_in_cents [Integer, nil] The amount (in cents) to refund.
-    # @param refund_method ["credit_first", "transaction_first", "all_transaction", "all_credit"] The method used to refund.
-    # @param external_refund [true, false] Designates that the refund transactions created are manual.
-    # @param credit_customer_notes [String] Adds notes to refund credit invoice.
-    # @param payment_method [String] Creates the manual transactions with this payment method. Allowed if *external_refund* is true.
-    # @param description [String] Sets this value as the *transaction_note* on the manual transactions created. Allowed if *external_refund* is true.
-    # @param refunded_at [DateTime] Sets this value as the *collected_at* on the manual transactions created. Allowed if *external_refund* is true.
-    def refund_amount(amount_in_cents = nil, refund_method = 'credit_first', options = {})
-      return false unless link? :refund
-      self.class.from_response(
-        follow_link :refund, :body => refund_amount_to_xml(amount_in_cents, refund_method, options)
-      )
-    end
-
-    def xml_keys
-      super - ['currency']
-    end
-
-    # Attempts to update the invoice, returning the success of the request.
-    # Raises an error if attempting to create an invoice using this method.
-    #
-    # @return [true, false]
-    # @raise [RuntimeError] Raises error if you attempt to create an invoice.
-    # @example
-    #   invoice = Recurly::Invoice.find('1000')
-    #   invoice.po_number = '1234'
-    #   invoice.save # => true
-    def save
-      unless persisted?
-        raise "Invoices can only be updated with Invoice#save. New invoices cannot be created using this method."
-      end
-      super
-    end
-
-    private
-
-    def initialize(attributes = {})
-      super({ :currency => Recurly.default_currency }.merge attributes)
-    end
-
-    def refund_amount_to_xml(amount_in_cents = nil, refund_method = nil, options = {})
-      builder = XML.new("<invoice/>")
-      builder.add_element 'refund_method', refund_method
-      builder.add_element 'amount_in_cents', amount_in_cents
-      options.each do |k, v|
-        builder.add_element k.to_s, v
-      end
-      builder.to_s
-    end
-
-    def refund_line_items_to_xml(line_items = nil, refund_method = nil, options = {})
-      builder = XML.new("<invoice/>")
-      builder.add_element 'refund_method', refund_method
-      options.each do |k, v|
-        builder.add_element k.to_s, v
-      end
-      line_items ||= []
-      node = builder.add_element 'line_items'
-      line_items.each do |line_item|
-        adj_node = node.add_element 'adjustment'
-        adj_node.add_element 'uuid', line_item[:adjustment].uuid
-        adj_node.add_element 'quantity', line_item[:quantity]
-        adj_node.add_element('quantity_decimal', line_item[:quantity_decimal]) if line_item.key?(:quantity_decimal)
-        adj_node.add_element 'prorate', line_item[:prorate]
-      end
-      builder.to_s
-    end
-
-    # Returns an xml body or nil given some options
-    def force_collect_xml(options = {})
-      if options[:transaction_type] || options[:billing_info]
-        ForceCollect.new(options).to_xml
-      end
-    end
-
-    # Invoices are only writeable through {Account} instances.
-    embedded! true
-    undef destroy
-
-    # Represents a body for the force collect endpoint
-    class ForceCollect < Resource
-      has_one :billing_info, class_name: :BillingInfo, readonly: false
-      define_attribute_methods %w[transaction_type]
-    end
-  end
-end

data/lib/recurly/invoice_collection.rb

@@ -1,14 +0,0 @@
-module Recurly
-  class InvoiceCollection < Resource
-    # @return [Invoice, nil]
-    has_one :charge_invoice, class_name: :Invoice, readonly: true
-
-    # @return [[Invoice], []]
-    has_many :credit_invoices, class_name: :Invoice, readonly: true
-
-    # These are readonly resources
-    embedded! true
-    undef save
-    undef destroy
-  end
-end

data/lib/recurly/invoice_template.rb

@@ -1,14 +0,0 @@
-module Recurly
-  class InvoiceTemplate < Resource
-    has_many :accounts, class_name: :Account, readonly: true
-
-    define_attribute_methods %w(
-      uuid
-      name
-      code
-      description
-      created_at
-      updated_at
-    )
-  end
-end

data/lib/recurly/item.rb

@@ -1,36 +0,0 @@
-module Recurly
-  class Item < Resource
-    # @return [[CustomField], []]
-    has_many :custom_fields, class_name: :CustomField, readonly: false
-
-    define_attribute_methods %w(
-      item_code
-      name
-      description
-      external_sku
-      accounting_code
-      revenue_schedule_type
-      state
-      avalara_transaction_type
-      avalara_service_type
-      created_at
-      updated_at
-      deleted_at
-    )
-
-    def changed_attributes
-      attrs = super
-      if custom_fields.any?(&:changed?)
-        attrs['custom_fields'] = custom_fields.select(&:changed?)
-      end
-      attrs
-    end
-
-    def reactivate
-      return false unless link? :reactivate
-      reload follow_link :reactivate
-      true
-    end
-
-  end
-end

data/lib/recurly/js.rb

@@ -1,14 +0,0 @@
-module Recurly
-  module JS
-    class << self
-      # @return [String] A public key for Recurly.js.
-      # @raise [ConfigurationError] No public key has been set.
-      def public_key
-        defined? @public_key and @public_key or raise(
-          ConfigurationError, "public_key not configured"
-        )
-      end
-      attr_writer :public_key
-    end
-  end
-end

data/lib/recurly/juris_detail.rb

@@ -1,15 +0,0 @@
-module Recurly
-  class JurisDetail < Resource
-    define_attribute_methods %w(
-      description
-      jurisdiction
-      rate
-      tax_in_cents
-      sub_type
-      jurisdiction_name
-      classification
-    )
-
-    embedded! true
-  end
-end

data/lib/recurly/measured_unit.rb

@@ -1,16 +0,0 @@
-module Recurly
-  # Measured Units are used in Recurly's usage-based billing feature.
-  #
-  # Recurly Documentation: https://dev.recurly.com/docs/measured-unit-object
-  class MeasuredUnit < Resource
-    define_attribute_methods %w(
-      id
-      name
-      display_name
-      description
-      created_at
-      updated_at
-    )
-    alias to_param id
-  end
-end

data/lib/recurly/money.rb

@@ -1,120 +0,0 @@
-module Recurly
-  # Represents a collection of currencies (in cents).
-  class Money
-    # @return A money object representing multiple currencies (in cents).
-    # @param currencies [Hash] A hash of currency codes and amounts.
-    # @example
-    #   # 12 United States dollars.
-    #   Recurly::Money.new :USD => 12_00
-    #
-    #   # $9.99 (or €6.99).
-    #   Recurly::Money.new :USD => 9_99, :EUR => 6_99
-    #
-    #   # Using a default currency.
-    #   Recurly.default_currency = 'USD'
-    #   Recurly::Money.new(49_00) # => #<Recurly::Money USD: 49_00>
-    def initialize currencies = {}, parent = nil, attribute = nil
-      @currencies = {}
-      @parent = parent
-      @attribute = attribute
-
-      if currencies.respond_to? :each_pair
-        currencies.each_pair { |key, value| @currencies[key.to_s] = value }
-      elsif Recurly.default_currency
-        self[Recurly.default_currency] = currencies
-      else
-        message = 'expected a Hash'
-        message << ' or Numeric' if Recurly.default_currency
-        message << " but received #{currencies.class}"
-        raise ArgumentError, message
-      end
-    end
-
-    def [] code
-      currencies[code.to_s]
-    end
-
-    def []= code, amount
-      currencies[code.to_s] = amount
-      @parent.send "#@attribute=", dup if @parent
-      amount
-    end
-
-    # @return [Hash] A hash of currency codes to amounts.
-    def to_hash
-      currencies.dup
-    end
-
-    # @return [true, false] Whether or not the currency is equal to another
-    # instance.
-    # @param other [Money]
-    def eql? other
-      other.respond_to?(:currencies) && currencies.eql?(other.currencies)
-    end
-
-    # @return [Integer] Unique identifier.
-    # @see Hash#hash
-    def hash
-      currencies.hash
-    end
-
-    # Implemented so that solitary currencies can be compared and sorted.
-    #
-    # @return [-1, 0, 1]
-    # @param other [Money]
-    # @example
-    #   [Recurly::Money.new(2_00), Recurly::Money.new(1_00)].sort
-    #   # => [#<Recurly::Money USD: 1_00>, #<Recurly::Money USD: 2_00>]
-    # @see Hash#<=>
-    def <=> other
-      if currencies.keys.length == 1 && other.currencies.length == 1
-        if currencies.keys == other.currencies.keys
-          return currencies.values.first <=> other.currencies.values.first
-        end
-      end
-
-      currencies <=> other.currencies
-    end
-
-    # @return [true, false]
-    # @see Object#respond_to?
-    def respond_to? method_name, include_private = false
-      super || currencies.respond_to?(method_name, include_private)
-    end
-
-    # @return [String]
-    def inspect
-      string = "#<#{self.class}"
-      if currencies.any?
-        string << " %s" % currencies.keys.sort.map { |code|
-          value = currencies[code].to_s
-          value.gsub!(/^(\d)$/, '0_0\1')
-          value.gsub!(/^(\d{2})$/, '0_\1')
-          value.gsub!(/(\d)(\d{2})$/, '\1_\2')
-          value.gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, '\1_')
-          "#{code}: #{value}"
-        }.join(', ')
-      end
-      string << '>'
-    end
-    alias to_s inspect
-
-    attr_reader :currencies
-
-    private
-
-    def method_missing name, *args, &block
-      if currencies.respond_to? name
-        return currencies.send name, *args, &block
-      elsif c = currencies[Recurly.default_currency] and c.respond_to? name
-        if currencies.keys.length > 1
-          raise TypeError, "can't convert multicurrency into Integer"
-        else
-          return c.send name, *args, &block
-        end
-      end
-
-      super
-    end
-  end
-end