gibbon 1.2.1 → 2.0.0

data/lib/gibbon/api.rb

@@ -1,38 +0,0 @@
-module Gibbon
-  class API
-    attr_accessor :api_key, :api_endpoint, :timeout, :throws_exceptions
-
-    def initialize(api_key = nil, default_parameters = {})
-      @api_key = api_key || self.class.api_key || ENV['MAILCHIMP_API_KEY']
-      @api_key = @api_key.strip if @api_key
-
-      @api_endpoint = default_parameters.delete(:api_endpoint) || self.class.api_endpoint
-      @timeout = default_parameters.delete(:timeout) || self.class.timeout
-      @throws_exceptions = default_parameters.has_key?(:throws_exceptions) ? default_parameters.delete(:throws_exceptions) : self.class.throws_exceptions
-
-      @default_params = {:apikey => @api_key}.merge(default_parameters)
-    end
-
-    def get_exporter
-      Export.new(@api_key, @default_params)
-    end
-
-    def method_missing(method, *args)
-      api = APICategory.new(method.to_s, @api_key, @timeout, @throws_exceptions, @api_endpoint, @default_params)
-      api.api_endpoint = @api_endpoint if @api_endpoint
-      api
-    end
-
-    def respond_to_missing?(method, include_private = false)
-      %w{campaigns ecomm folders gallery lists helper reports templates users vip}.include?(method.to_s) || super
-    end
-
-    class << self
-      attr_accessor :api_key, :timeout, :throws_exceptions, :api_endpoint
-
-      def method_missing(sym, *args, &block)
-        new(self.api_key, {:api_endpoint => self.api_endpoint, :timeout => self.timeout, :throws_exceptions => self.throws_exceptions}).send(sym, *args, &block)
-      end
-    end
-  end
-end

data/lib/gibbon/api_category.rb

@@ -1,110 +0,0 @@
-require 'gibbon/api'
-
-module Gibbon
-  class APICategory
-    include HTTParty
-    format :plain
-    default_timeout 30
-
-    attr_accessor :category_name, :api_key, :api_endpoint, :timeout, :throws_exceptions, :default_params
-
-    def initialize(category_name, api_key, timeout, throws_exceptions, api_endpoint, default_params)
-      @category_name = category_name
-      @api_key = api_key
-      @api_endpoint = api_endpoint
-      @default_params = default_params
-      @throws_exceptions = throws_exceptions
-      @timeout = timeout
-
-      set_instance_defaults
-    end
-
-    def call(method, params = {})
-      ensure_api_key params
-
-      api_url = base_api_url + method
-      params = @default_params.merge(params).merge({:apikey => @api_key})
-      headers = params.delete(:headers) || {}
-      response = self.class.post(api_url, :body => MultiJson.dump(params), :headers => headers, :timeout => @timeout)
-
-      parse_response(response.body) if response.body
-    end
-
-    def parse_response(response, check_error = true)
-      begin
-        parsed_response = MultiJson.load(response)
-      rescue MultiJson::ParseError
-        parsed_response = {
-          "error" => "Unparseable response: #{response}",
-          "name" => "UNPARSEABLE_RESPONSE",
-          "code" => 500
-        }
-      end
-
-      if should_raise_for_response?(parsed_response)
-        error = MailChimpError.new(parsed_response["error"])
-        error.code = parsed_response["code"]
-        error.name = parsed_response["name"]
-        raise error
-      end
-      parsed_response
-    end
-
-    def method_missing(method, *args)
-      # To support underscores, we replace them with hyphens when calling the API
-      method = method.to_s.gsub("_", "-").downcase
-      call("#{@category_name}/#{method}", *args)
-    end
-
-    def send(*args)
-      if ((args.length > 0) && args[0].is_a?(Hash))
-        method_missing(:send, args[0])
-      else
-        __send__(*args)
-      end
-    end
-
-    def set_instance_defaults
-      @timeout = (API.timeout || 30) if @timeout.nil?
-      # Two lines because the class variable could be false and (false || true) is always true
-      @throws_exceptions = API.throws_exceptions if @throws_exceptions.nil?
-      @throws_exceptions = true if @throws_exceptions.nil?
-    end
-
-    def api_key=(value)
-      @api_key = value.strip if value
-    end
-
-    def should_raise_for_response?(response)
-      @throws_exceptions && response.is_a?(Hash) && response["error"]
-    end
-
-    def base_api_url
-      "#{@api_endpoint || get_api_endpoint}/2.0/"
-    end
-
-    def get_api_endpoint
-      "https://#{get_data_center_from_api_key}api.mailchimp.com"
-    end
-
-    def get_data_center_from_api_key
-      # Return an empty string for invalid API keys so Gibbon hits the main endpoint
-      data_center = ""
-
-      if (@api_key && @api_key["-"])
-        # Add a period since the data_center is a subdomain and it keeps things dry
-        data_center = "#{@api_key.split('-').last}."
-      end
-
-      data_center
-    end
-
-    private
-
-    def ensure_api_key(params)
-      unless @api_key || @default_params[:apikey] || params[:apikey]
-        raise Gibbon::GibbonError, "You must set an api_key prior to making a call"
-      end
-    end
-  end
-end

data/lib/gibbon/export.rb

@@ -1,106 +0,0 @@
-module Gibbon
-  class Export < APICategory
-
-    def initialize(api_key = nil, default_params = {})
-      @api_key = api_key
-      @default_params = default_params
-
-      set_instance_defaults
-    end
-
-    protected
-
-    def export_api_url
-      "http://#{get_data_center_from_api_key}api.mailchimp.com/export/1.0/"
-    end
-
-    # fsluis: Alternative, streaming, interface to mailchimp export api
-    #         Prevents having to keep lots of data in memory
-    def call(method, params = {}, &block)
-      rows = []
-
-      api_url = export_api_url + method + "/"
-      params = @default_params.merge(params).merge({:apikey => @api_key})
-      block = Proc.new { |row| rows << row } unless block_given?
-      ensure_api_key params
-
-      url = URI.parse(api_url)
-      req = Net::HTTP::Post.new(url.path, initheader = {'Content-Type' => 'application/json'})
-      req.body = MultiJson.dump(params)
-      Net::HTTP.start(url.host, url.port, :read_timeout => @timeout) do |http|
-        # http://stackoverflow.com/questions/29598196/ruby-net-http-read-body-nethttpokread-body-called-twice-ioerror
-        http.request req do |response|
-          i = -1
-          last = ''
-          response.read_body do |chunk|
-            next if chunk.nil? or chunk.strip.empty?
-            last += "\n" if last[-1, 1]==']'
-            lines = (last+chunk).split("\n")
-            last = lines.pop || ''
-            lines.each do |line|
-              block.call(parse_response(line, i < 0), i += 1) unless line.nil?
-            end
-          end
-          block.call(parse_response(last, i < 0), i += 1) unless last.nil? or last.empty?
-        end
-      end
-      rows unless block_given?
-    end
-
-    def parse_response(res, check_error)
-      return [] if res.strip.empty?
-      super(res, check_error)
-    end
-
-    def set_instance_defaults
-      @api_key = self.class.api_key if @api_key.nil?
-      @timeout = self.class.timeout if @timeout.nil?
-      super
-    end
-
-    # fsluis: added a &block to this method and function call
-    def method_missing(method, *args, &block)
-      # To support underscores, we camelize the method name
-
-      # Thanks for the camelize gsub, Rails
-      method = method.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
-
-      # We need to downcase the first letter of every API method
-      # and MailChimp has a few of API methods that end in "AIM," which
-      # must be upcased (See "Campaign Report Data Methods" in their API docs).
-      method = method[0].chr.downcase + method[1..-1].gsub(/aim$/i, 'AIM')
-
-      call(method, *args, &block)
-    end
-
-    def respond_to_missing?(method, include_private = false)
-      %w{list ecommOrders ecomm_orders campaignSubscriberActivity campaign_subscriber_activity}.include?(method.to_s) || super
-    end
-
-    private
-
-    def split_json(lines, delimiter)
-      lines.map do |line|
-        if line.include? delimiter
-          line.split(delimiter).each_with_index.map{ |s, i|  i % 2 == 0 ? s + delimiter[0] : delimiter[1] + s }
-        else
-          line
-        end
-      end.flatten
-    end
-
-    def ensure_api_key(params)
-      unless @api_key || @default_params[:apikey] || params[:apikey]
-        raise Gibbon::GibbonError, "You must set an api_key prior to making a call"
-      end
-    end
-
-    class << self
-      attr_accessor :api_key, :timeout, :throws_exceptions
-
-      def method_missing(sym, *args, &block)
-        new(self.api_key, {:timeout => self.timeout, :throws_exceptions => self.throws_exceptions}).send(sym, *args, &block)
-      end
-    end
-  end
-end