recurly 0.4.16 → 2.0.0

data/lib/recurly/coupon.rb

@@ -1,13 +1,68 @@
 module Recurly
-  class Coupon < AccountBase
-    self.element_name = "coupon"
-
-    def self.known_attributes
-      [
-        "coupon_code",
-        "redeemed_at"
-      ]
+  class Coupon < Resource
+    # @macro [attach] scope
+    #   @scope class
+    #   @return [Pager<Coupon>] A pager that yields +$1+ coupons.
+    scope :redeemable, :state => :redeemable
+    scope :expired,    :state => :expired
+    scope :maxed_out,  :state => :maxed_out
+
+    # @return [Pager<Redemption>]
+    has_many :redemptions
+
+    define_attribute_methods %w(
+      coupon_code
+      name
+      state
+      discount_type
+      discount_percent
+      discount_in_cents
+      redeem_by_date
+      single_use
+      applies_for_months
+      max_redemptions
+      applies_to_all_plans
+      created_at
+      currencies
+      plan_codes
+    )
+    alias to_param coupon_code
+
+    # Redeem a coupon with a given account or account code.
+    #
+    # @return [true]
+    # @param account_or_code [Account, String]
+    # @example
+    #   coupon = Coupon.find coupon_code
+    #   coupon.redeem account_code
+    #
+    #   coupon = Coupon.find coupon_code
+    #   account = Account.find account_code
+    #   coupon.redeem account
+    def redeem account_or_code, currency = nil
+      return false unless self[:redeem]
+
+      account_code = if account_or_code.is_a? Account
+        account_or_code.account_code
+      else
+        account_or_code
+      end
+
+      Redemption.from_response self[:redeem].call(
+        :body => (redemption = redemptions.new(
+          :account_code => account_code,
+          :currency     => currency || Recurly.default_currency
+        )).to_xml
+      )
+    rescue API::UnprocessableEntity => e
+      redemption.apply_errors e
+      redemption
     end
 
+    def redeem! account_code, currency = nil
+      redemption = redeem account_code, currency
+      raise Invalid.new(self) unless redemption.persisted?
+      redemption
+    end
   end
 end

data/lib/recurly/helper.rb

@@ -0,0 +1,39 @@
+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.to_s.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
+      Hash.new { |hash, key| hash[key.to_s] if key.is_a? Symbol }
+    end
+
+    extend self
+  end
+end

data/lib/recurly/invoice.rb

@@ -1,24 +1,46 @@
 module Recurly
-  class Invoice < Base
-    self.element_name = "invoice"
-    self.prefix = "/accounts/:account_code/"
+  # Invoices are created through account objects.
+  #
+  # @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 :open,      :state => :open
+    scope :collected, :state => :collected
+    scope :failed,    :state => :failed
+    scope :past_due,  :state => :past_due
 
-    def self.list(account_code)
-      find(:all, :params => { :account_code => account_code })
-    end
+    # @return [Account]
+    belongs_to :account
 
-    def self.lookup(account_code, id)
-      find(id, :params => { :account_code => account_code })
-    end
+    define_attribute_methods %w(
+      uuid
+      state
+      invoice_number
+      po_number
+      vat_number
+      subtotal_in_cents
+      tax_in_cents
+      total_in_cents
+      currency
+      created_at
+      line_items
+      transactions
+    )
+    alias to_param uuid
 
-    def self.element_path(id, prefix_options = {}, query_options = nil)
-      path = super
+    private
 
-      # postprocess generated element url.
-      # changes /accounts/:account_code/invoices/:id to /invoices/:id
-      # this breaks update, however I dont believe recurly allows invoice updates anyways
-      path.sub("/accounts/#{CGI::escape(prefix_options[:account_code].to_s)}/invoices/", "/invoices/")
+    def initialize attributes = {}
+      super({ :currency => Recurly.default_currency }.merge attributes)
     end
 
+    # Invoices are only writeable through {Account} instances.
+    embedded!
+    undef save
+    undef destroy
   end
-end
+end

data/lib/recurly/js.rb

@@ -0,0 +1,113 @@
+require 'openssl'
+
+module Recurly
+  # A collection of helper methods to use to verify
+  # {Recurly.js}[http://js.recurly.com/] callbacks.
+  module JS
+    # Raised when signature verification fails.
+    class RequestForgery < Error
+    end
+
+    # Used to prevent strings from being escaped during digest.
+    class SafeString < String
+    end
+
+    class << self
+      # @return [String] A private key for Recurly.js.
+      # @raise [ConfigurationError] No private key has been set.
+      def private_key
+        defined? @private_key and @private_key or raise(
+          ConfigurationError, "private_key not configured"
+        )
+      end
+      attr_writer :private_key
+
+      # @return [String]
+      def sign_billing_info account_code
+        sign 'billinginfoupdate', 'account_code' => account_code
+      end
+
+      # @return [String]
+      def sign_transaction amount_in_cents, currency = nil, account_code = nil
+        sign 'transactioncreate', {
+          'amount_in_cents' => amount_in_cents,
+          'currency'        => currency || Recurly.default_currency,
+          'account_code'    => account_code
+        }
+      end
+
+      # @return [true]
+      # @raise [RequestForgery] If verification fails.
+      def verify_billing_info! params
+        verify! 'billinginfoupdated', params
+      end
+
+      # @return [true]
+      # @raise [RequestForgery] If verification fails.
+      def verify_transaction! params
+        verify! 'subscriptioncreated', params
+      end
+
+      # @return [true]
+      # @raise [RequestForgery] If verification fails.
+      def verify_subscription! params
+        verify! 'subscriptioncreated', params
+      end
+
+      # @return [String]
+      def inspect
+        'Recurly.js'
+      end
+
+      private
+
+      def sign claim, params, timestamp = Time.now
+        signature = OpenSSL::HMAC.hexdigest(
+          OpenSSL::Digest::Digest.new('SHA1'),
+          Digest::SHA1.digest(private_key),
+          digest([Time.now.to_i, claim, params])
+        )
+        "#{signature}-#{timestamp}"
+      end
+
+      def verify! claim, params
+        params = Hash[params.map { |key, value| [key.to_s, value] }]
+        signature = params.delete('signature') or raise(
+          RequestForgery, 'missing signature'
+        )
+        timestamp = signature.split('-').last
+        age = Time.now.to_i - timestamp.to_i
+        unless (-3600..3600).include? age
+          raise RequestForgery, 'stale timestamp'
+        end
+
+        if signature != sign(claim, params, timestamp)
+          raise RequestForgery,
+            "signature can't be verified (invalid request or private key)"
+        end
+
+        true
+      end
+
+      def digest data
+        case data
+        when Array
+          return if data.empty?
+          SafeString.new "[#{data.map { |d| digest d }.compact.join ','}]"
+        when Hash
+          data = Hash[data.map { |key, value| [key.to_s, value] }]
+          digest data.keys.sort.map { |key|
+            next unless value = digest(data[key])
+            SafeString.new "#{"#{key}:" unless key =~ /^\d+$/}#{value}"
+          }
+        when SafeString
+          data
+        when String
+          SafeString.new data.gsub(/([\[\]\,\:\\])/, '\\\\\1')
+        else
+          data
+        end
+      end
+    end
+  end
+end

data/lib/recurly/money.rb

@@ -0,0 +1,105 @@
+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 = {}
+      @currencies = Helper.hash_with_indifferent_read_access
+
+      if currencies.respond_to? :each_pair
+        currencies.each_pair { |key, value| @currencies[key.to_s] = value }
+      else
+        @currencies[Recurly.default_currency] = currencies
+      end
+    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
+
+    protected
+
+    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

data/lib/recurly/plan.rb

@@ -1,18 +1,29 @@
 module Recurly
-  class Plan < Base
-    self.element_name = "plan"
-    self.primary_key = :plan_code
-
-    def self.known_attributes
-      [
-        "plan_code",
-        "name",
-        "description",
-        "success_url",
-        "cancel_url",
-        "created_at"
-      ]
-    end
+  class Plan < Resource
+    # @return [Pager<AddOn>, Array]
+    has_many :add_ons
 
+    define_attribute_methods %w(
+      plan_code
+      name
+      description
+      success_url
+      cancel_url
+      display_donation_amounts
+      display_quantity
+      display_phone_number
+      bypass_hosted_confirmation
+      unit_name
+      payment_page_tos_link
+      payment_page_css
+      setup_fee_in_cents
+      unit_amount_in_cents
+      plan_interval_length
+      plan_interval_unit
+      trial_interval_length
+      trial_interval_unit
+      created_at
+    )
+    alias to_param plan_code
   end
-end
+end

data/lib/recurly/redemption.rb

@@ -0,0 +1,34 @@
+module Recurly
+  # Redemptions are not top-level resources, but they can be accessed (and
+  # created) through {Coupon} instances.
+  #
+  # @example
+  #   coupon = Coupon.find "summer2011"
+  #   coupon.redemptions.each { |r| p r }
+  #   coupon.redeem Account.find("groupon_lover")
+  class Redemption < Resource
+    # @return [Coupon]
+    belongs_to :coupon
+    # @return [Account]
+    belongs_to :account, :readonly => false
+
+    define_attribute_methods %w(
+      single_use
+      total_discounted_in_cents
+      currency
+      created_at
+    )
+
+    def save
+      return false if persisted?
+      copy_from coupon.redeem account, currency
+      true
+    rescue Recurly::API::UnprocessableEntity => e
+      apply_errors e
+      false
+    end
+
+    # Redemptions are only writeable through {Coupon} instances.
+    embedded!
+  end
+end