recurly 0.4.16 → 2.0.0

data/lib/recurly/charge.rb

@@ -1,39 +0,0 @@
-module Recurly
-  class Charge < Base
-    self.element_name = "charge"
-    self.prefix = "/accounts/:account_code/"
-
-    def self.known_attributes
-      [
-        "account_code",
-        "quantity",
-        "unit_amount_in_cents",
-        "amount_in_cents", # quantity * unit_amount_in_cents
-        "start_date",
-        "end_date",
-        "description",
-        "created_at"
-      ]
-    end
-
-    def self.list(account_code, status = :all)
-      params = {:account_code => account_code}
-
-      if status != :all
-        params[:show] = status.to_s
-      end
-
-      find(:all, :params => params)
-    end
-
-    def self.lookup(account_code, id)
-      find(id, :params => { :account_code => account_code })
-    end
-
-    # def destroy
-    #   reload
-    #   return false if respond_to?(:invoice_id) and invoice_id.present?
-    #   super
-    # end
-  end
-end

data/lib/recurly/config_parser.rb

@@ -1,31 +0,0 @@
-require 'erb'
-require 'fileutils'
-require 'yaml'
-
-module Recurly
-  module ConfigParser
-    class << self
-
-      def parse(path = nil)
-        path ||= Recurly.settings_path
-        settings = {}
-        if File.exists?(path)
-          settings = YAML::load(ERB.new(File.read(path)).result) || {}
-        else
-          puts "\n#{path} file not found. Run rake recurly:setup to create one\n\n"
-        end
-
-        settings
-      end
-
-      def save(settings = {}, path = nil)
-        path ||= Recurly.settings_path
-        FileUtils.mkdir_p(File.dirname(path))
-        File.open(path, 'w' ) do |out|
-          YAML.dump(settings, out)
-        end
-      end
-    end
-  end
-
-end

data/lib/recurly/credit.rb

@@ -1,28 +0,0 @@
-module Recurly
-  class Credit < Base
-    self.element_name = "credit"
-    self.prefix = "/accounts/:account_code/"
-
-    def self.known_attributes
-      [
-        "account_code",
-        "quantity",
-        "unit_amount_in_cents",
-        "amount_in_cents", # quantity * unit_amount_in_cents
-        "start_date",
-        "end_date",
-        "description",
-        "created_at"
-      ]
-    end
-
-    def self.list(account_code)
-      find(:all, :params => { :account_code => account_code })
-    end
-
-    def self.lookup(account_code, id)
-      find(id, :params => { :account_code => account_code })
-    end
-
-  end
-end

data/lib/recurly/exceptions.rb

@@ -1,32 +0,0 @@
-require 'active_resource/exceptions'
-require 'active_resource/validations'
-
-module Recurly
-  class RecurlyError < StandardError; end
-  
-  class ConfigurationError < RecurlyError; end
-  
-  # Query string has been tampered with and cannot be trusted.
-  class ForgedQueryString < RecurlyError; end
-
-  # Transparent Post -- validations failed or transaction failed. See the {model} for errors.
-  class ValidationsFailed < RecurlyError
-    attr_reader :model
-
-    def initialize(model)
-      @model = model
-    end
-
-  end
-
-  class ResourceInvalid < ::ActiveResource::ResourceInvalid
-    # Overridden to print the actual error message
-    def to_s
-      message = "Failed."
-      message << "  Response code = #{response.code}." if response.respond_to?(:code)
-      message << "  Response message = #{@message}." if @message
-      message
-    end
-  end
-  
-end

data/lib/recurly/formats/xml_with_errors.rb

@@ -1,132 +0,0 @@
-require 'nokogiri'
-
-module Recurly
-  module Formats
-    class XmlWithErrorsFormat
-      include ActiveResource::Formats::XmlFormat
-
-      def decode(xml)
-        doc = Nokogiri::XML(xml)
-        data = xml_node_to_hash(doc.root)
-
-        if data.is_a?(Hash) and data["type"] == 'collection' and data["current_page"]
-          data = paginate_data(data)
-        end
-
-        data
-      end
-
-      def xml_node_to_hash(node)
-        return node.content.to_s.strip unless node.element?
-
-        node_type = xml_node_type(node)
-        if node.children.size == 1 && node.children[0].text?
-          return [] if node_type == 'array'
-          return xml_node_value(node)
-        end
-
-        if node.name == 'errors'
-          return node.children.collect do |child|
-            error_xml_node_to_hash(child) if child.name == 'error'
-          end.reject { |n| n.nil? }
-        elsif node_type == 'array'
-          return node.children.collect do |child|
-            xml_node_to_hash(child)
-          end.reject { |n| n.nil? || (n.is_a?(String) && n.blank?) }
-        end
-        
-        return nil if node.children.empty?
-
-        result_hash = {}
-        result_hash['type'] = node_type unless node_type.nil?
-
-        node.children.each do |child|
-          child_name = child.name
-          result = xml_node_to_hash(child)
-
-          next if child_name == 'text' && result == ''
-
-          if result_hash[child_name]
-            next if result == ''
-            if result_hash[child_name].is_a?(Array)
-              result_hash[child_name] << result
-            else
-              result_hash[child_name] = [result_hash[child_name]] << result
-            end
-          else
-            result_hash[child_name] = result
-          end
-        end
-
-        result_hash
-      end
-      
-      def error_xml_node_to_hash(node)
-        xml_attributes(node).merge('message' => node.children[0].content.to_s)
-      end
-
-      def xml_node_value(node)
-        return nil if xml_node_nil?(node)
-
-        case xml_node_type(node)
-        when 'integer'
-          node.content.to_i
-        when 'boolean'
-          ['true','1'].include?(node.content.downcase)
-        when 'datetime'
-          Time.parse(node.content)
-        else
-          node.content.to_s.strip
-        end
-      end
-
-      def xml_node_nil?(node)
-        return true if node.nil?
-        attr_node = node.attribute('nil')
-        attr_node.nil? ? false : true
-      end
-      
-      def xml_node_type(node)
-        attr_node = node.attribute('type')
-        attr_node.nil? ? nil : attr_node.value
-      end
-      
-      def xml_attributes(node)
-        return {} if node.attribute_nodes.empty?
-        values = {}
-        node.attribute_nodes.each do |attribute|
-          values[attribute.name] = attribute.value
-        end
-        values
-      end
-
-      # convert the data into a paginated resultset (array with singleton methods)
-      def paginate_data(data)
-        per_page = data["per_page"] || 0
-        current_page = data["current_page"] || 0
-        total_entries = data["total_entries"] || 0
-
-        # find the first array and use that as the resultset (lame workaround)
-        results = data.values.select{|v| v.is_a?(Array)}.first || []
-        if results.empty?
-          data.delete("per_page")
-          data.delete("current_page")
-          data.delete("total_entries")
-          data.delete("type")
-          results = [data.values.first].compact
-        end
-
-        # define total_entries accessor on result object
-        results.instance_eval "def total_entries; #{total_entries.to_i}; end"
-
-        # define current_page accessor on result object
-        results.instance_eval "def current_page; #{current_page.to_i}; end"
-
-        # define per_page accessor on result object
-        results.instance_eval "def per_page; #{per_page.to_i}; end"
-
-        results
-      end
-    end
-  end
-end

data/lib/recurly/formats/xml_with_pagination.rb

@@ -1,47 +0,0 @@
-module Recurly
-  module Formats
-    class XmlWithPaginationFormat
-      include ActiveResource::Formats::XmlFormat
-
-      def decode(xml)
-        data = super
-
-        if data.is_a?(Hash) and data["type"] == "collection" and data["current_page"]
-          data = paginate_data(data)
-        end
-
-        data
-      end
-
-      # convert the data into a paginated resultset (array with singleton methods)
-      def paginate_data(data)
-
-        per_page = data["per_page"] || 0
-        current_page = data["current_page"] || 0
-        total_entries = data["total_entries"] || 0
-
-        # find the first array and use that as the resultset (lame workaround)
-        results = data.values.select{|v| v.is_a?(Array)}.first || []
-        if results.empty?
-          data.delete("per_page")
-          data.delete("current_page")
-          data.delete("total_entries")
-          data.delete("type")
-          results = [data.values.first].compact
-        end
-
-        # define total_entries accessor on result object
-        results.instance_eval "def total_entries; #{total_entries.to_i}; end"
-
-        # define current_page accessor on result object
-        results.instance_eval "def current_page; #{current_page.to_i}; end"
-
-        # define per_page accessor on result object
-        results.instance_eval "def per_page; #{per_page.to_i}; end"
-
-        results
-      end
-    end
-  end
-end
-

data/lib/recurly/rails2/compatibility.rb

@@ -1,8 +0,0 @@
-# ActiveResource workaround for Rails 2.x
-# https://rails.lighthouseapp.com/projects/8994/tickets/1472-activeresource-222-errorsfrom_xml-cant-handle-symboled-attribute-keys-because-of-humanize-call
-#
-class Symbol
-  def humanize
-    to_s.humanize
-  end
-end

data/lib/recurly/rails3/railtie.rb

@@ -1,21 +0,0 @@
-module Recurly
-  class Railtie < ::Rails::Railtie
-    rake_tasks do
-      load 'recurly/rails3/recurly.rake'
-    end
-
-    config.after_initialize do
-      Recurly.configure unless Recurly.configured?
-    end
-
-    initializer :recurly_set_accept_language do
-      ActionController::Base.class_eval do
-        prepend_before_filter do
-          # used to default the current accept language to the latest request
-          Recurly.current_accept_language = request.env["HTTP_ACCEPT_LANGUAGE"]
-        end
-      end
-    end
-
-  end
-end

data/lib/recurly/rails3/recurly.rake

@@ -1,28 +0,0 @@
-namespace :recurly do
-
-  # loads settings
-  task :load_settings => :environment do
-    # load the recurly.yml file
-    @recurly_config = Recurly::ConfigParser.parse
-  end
-
-  def setup_static
-    @recurly_config["api_key"] ||= "my_api_key"
-    @recurly_config["private_key"] ||= "my_private_key"
-    @recurly_config["subdomain"] ||= "mysite"
-  end
-
-  desc "Creates a recurly.yml config file"
-  task :setup => :environment do
-
-    # load the recurly.yml file
-    Rake::Task["recurly:load_settings"].invoke
-
-    setup_static
-    puts "Settings file generated at:\n#{Recurly.settings_path}\n"
-    puts "Edit this file to configure your Recurly settings.\n"
-
-    # saves the yml file
-    Recurly::ConfigParser.save(@recurly_config)
-  end
-end

data/lib/recurly/transparent.rb

@@ -1,148 +0,0 @@
-require 'erb'
-
-module Recurly
-
-  module Action
-    CreateSubscription = "subscription"
-    UpdateBilling = "billing_info"
-    CreateTransaction = "transaction"
-  end
-
-  class Transparent
-    attr_accessor :data
-
-    def initialize(data = {})
-      @data = data || {}
-    end
-
-    # output the transparent data as a hidden field
-    def hidden_field
-      html = %{<input type="hidden" name="data" value="#{ERB::Util.html_escape(encoded_data)}" />}
-
-      if html.respond_to?(:html_safe)
-        html.html_safe
-      else
-        html
-      end
-    end
-
-    # output transparent data along with a verification string to prevent tampering of data
-    def encoded_data
-      verify_required_fields
-
-      # convert data to a query string
-      query_data = self.class.query_string(data)
-
-      # generate a validation string by encrypting the string using the private key
-      validation_string = self.class.encrypt_string(query_data)
-
-      # return the validation and query data
-      "#{validation_string}|#{query_data}"
-    end
-
-    # verify that certain fields are present (or else the transparent post wont work)
-    def verify_required_fields
-      # make sure there's a redirect_url defined
-      unless @data.has_key?(:redirect_url)
-        raise "A :redirect_url key must be defined for Transparent posts"
-      end
-      unless @data.has_key?(:account)
-        raise "An :account key must be defined for Transparent posts"
-      end
-      unless @data[:account].has_key?(:account_code)
-        raise "An :account[:account_code] key must be defined for Transparent posts"
-      end
-
-      return true
-    end
-
-    # convert data into query string
-    def self.query_string(data = {})
-      # process data
-      data = process_data(data.dup)
-      data[:time] = Time.now.utc.strftime("%d/%b/%Y %H:%M:%S %Z")
-
-      address = Addressable::URI.new
-      address.query_values = data
-      address.query
-    end
-
-    # returns the url to post to
-    def self.url(action = nil)
-      raise Recurly::ConfigurationError.new("Recurly gem not configured. run `rake recurly:setup`") unless Recurly.configured?
-      raise Recurly::ConfigurationError.new("Recurly gem not configured. 'private_key' missing.") if Recurly.private_key.blank?
-      raise Recurly::ConfigurationError.new("Recurly gem not configured. 'subdomain' missing.") if Recurly.subdomain.blank?
-
-      # default action to create new subscription
-      action ||= Action::CreateSubscription
-
-      URI.parse("#{Recurly::Base.site}/").merge("/transparent/#{Recurly.subdomain}/#{action}").to_s
-    end
-
-    def self.create_subscription_url
-      url(Action::CreateSubscription)
-    end
-
-    def self.create_transaction_url
-      url(Action::CreateTransaction)
-    end
-
-    def self.update_billing_url
-      url(Action::UpdateBilling)
-    end
-
-    # returns the results via a code
-    def self.results(params)
-      # pull out the result key and status
-      type = params["type"]
-      result_key = params["result"]
-      status = params["status"]
-
-      # verify confirmation matches the passed in querystring
-      address = Addressable::URI.new
-      address.query_values = {:type => type.to_s, :status => status.to_s, :result => result_key.to_s}
-      raise Recurly::ForgedQueryString.new if params["confirm"] != encrypt_string(address.query)
-
-      # pull the class name
-      model = Recurly.const_get(type.to_s.classify)
-
-      response = nil
-      begin
-        # rebuild the ActiveResource object from the xml results
-        response = Recurly::Base.connection.get_raw("/transparent/results/#{result_key}", model.headers)
-        return model.new.from_transparent_results(response)
-
-      rescue ActiveResource::ResourceInvalid => ex
-        model_result = model.new.from_transparent_results(ex.response)
-        raise Recurly::ValidationsFailed.new(model_result)
-      end
-    end
-
-    # encode a string using the configured private key
-    def self.encrypt_string(input_string)
-      raise Recurly::ConfigurationError.new("Recurly gem not configured. To use transparent redirects, set your private_key within config/recurly.yml to the private_key provided by recurly.com") unless Recurly.private_key.present?
-      digest_key = ::Digest::SHA1.digest(Recurly.private_key)
-      sha1_hash = ::OpenSSL::Digest::Digest.new("sha1")
-      ::OpenSSL::HMAC.hexdigest(sha1_hash, digest_key, input_string.to_s)
-    end
-
-    # recursively process the query data (running to_s on values)
-    def self.process_data(data = {})
-      return data unless data.is_a?(Hash)
-      data.each do |key, val|
-        if val.is_a?(Hash)
-          data[key] = process_data(val)
-        elsif val.is_a?(String)
-          data[key] = val.to_s
-        elsif val.is_a?(Enumerable)
-          values = Hash.new
-          val.each_with_index{ |item, index| values[index] = process_data(item) }
-          data[key] = values
-        else
-          data[key] = val.to_s
-        end
-      end
-    end
-  end
-end
-