chubasaweber 0.0.0

data/lib/aweber/base.rb

@@ -0,0 +1,57 @@
+module AWeber
+  class Base
+
+    def initialize(oauth)
+      @oauth = oauth
+    end
+
+    def account
+      accounts.first.last
+    end
+    
+    def get(uri)
+      response = oauth.get(expand(uri))
+      handle_errors(response, uri)
+      parse(response) if response
+    end
+    
+    def delete(uri)
+      oauth.delete(expand(uri))
+    end
+    
+    def put(uri, body={})
+      oauth.put(uri, body.to_json, {"Content-Type" => "application/json"})
+    end
+
+  private
+    
+    def handle_errors(response, uri)
+      if response.is_a? Net::HTTPNotFound
+        raise NotFoundError, "Invalid resource uri.", caller
+      elsif response && response.body == "NotAuthorizedError"
+        raise OAuthError, "Could not authorize OAuth credentials.", caller
+      end
+    end
+
+    def accounts
+      @accounts ||= Collection.new(self, Resources::Account, get("/accounts"))
+    end
+
+    def expand(uri)
+      parsed = URI.parse(uri)
+      url = []
+      url << AWeber.api_endpoint
+      url << API_VERSION unless parsed.path.include? API_VERSION
+      url << parsed.path
+      File.join(*url)
+    end
+
+    def parse(response)
+      ActiveSupport::JSON.decode(response.body)
+    end
+
+    def oauth
+      @oauth
+    end
+  end
+end

data/lib/aweber/collection.rb

@@ -0,0 +1,110 @@
+module AWeber
+  # Collection objects are groups of Resources. Collections imitate
+  # regular Hashes in most ways. You can access Resource by +id+ via the
+  # +[]+ method.
+  #
+  #    lists    #=> #<AWeber::Collection ...>
+  #    lists[1] #=> #<AWeber::Resources::List @id=1 ...>
+  #
+  # Also like Hashes, you can iterate over all of it's entries
+  #
+  #    lists.each { |id, list| puts list.name }
+  #
+  # Collections support dynamic +find_by_*+ methods, where +*+ is an
+  # attribute and the first and only parameter is the value.
+  #
+  #    lists.find_by_name("testlist")
+  #    #=> #<AWeber::Resources::List @id=123, @name="testlist" ...>
+  #
+  # +find_by_*+ methods will also return a Hash of entries if more than 
+  # one matches the criteria. The hash will be keyed by resource ID.
+  #
+  #    messages.find_by_total_opens(0)
+  #    #=> { "45697" => #<Message>, "12345" => #<Message> }
+  #
+  # Collections are paginated in groups of 20.
+  #
+  class Collection < Resource
+    include Enumerable
+
+    attr_reader :entries
+    attr_reader :next_collection_link
+    attr_reader :prev_collection_link
+    attr_reader :resource_type_link
+    attr_reader :total_size
+
+    alias_method :size,   :total_size
+    alias_method :length, :total_size
+
+    # @param [AWeber::Base] client    Instance of AWeber::Base
+    # @param [Class] klass            Class to create entries of
+    # @param [Hash]  data             JSON decoded response data Hash
+    #
+    def initialize(client, klass, data={})
+      super client, data
+      @client  = client
+      @klass   = klass
+      @entries = {}
+      create_entries(data["entries"])
+      @_entries = @entries.to_a
+    end
+
+    def [](id)
+      @entries[id] ||= fetch_entry(id)
+    end
+
+    def each
+      (1..@total_size).each { |n| yield get_entry(n) }
+    end
+
+    def inspect
+      "#<AW::Collection(#{@klass.to_s}) size=\"#{size}\">"
+    end
+
+  private
+
+    def create_entries(entries)
+      entries.each { |entry| @entries[entry["id"]] = @klass.new(client, entry) }
+    end
+
+    def get_entry(n)
+      @_entries += fetch_next_group if needs_next_group?(n)
+      @_entries[n-1]
+    end
+
+    def fetch_entry(id)
+      @klass.new(client, get(File.join(base_path, id.to_s)))
+    end
+
+    def fetch_next_group(amount=20)
+      path = "#{ base_path }?ws.start=#{ @_entries.size }&ws.size=#{ amount }"
+      self.class.new(client, @klass, get(path)).entries.to_a
+    end
+
+    def needs_next_group?(current_index)
+      current_index == @_entries.size && current_index != @total_size
+    end
+
+    def base_path
+      URI.parse(@next_collection_link).path
+    end
+
+    def find_by(_attr, *args)
+      matches = select { |id, e| e.send(_attr) == args.first }
+      matches = matches.first.last if matches.size == 1
+      matches
+    end
+
+    def method_missing(method, *args)
+      method.to_s.scan /^find_by_(.+)/ do |_attr|
+        return find_by(_attr.first, *args)
+      end
+      super
+    end
+
+    def client
+      @client
+    end
+
+  end
+end

data/lib/aweber/oauth.rb

@@ -0,0 +1,69 @@
+module AWeber
+  class OAuth
+    extend Forwardable
+
+    def_delegators :access_token, :get, :post, :put, :delete
+
+    attr_accessor :callback_url
+
+    def initialize(consumer_token, consumer_secret, options={})
+      @consumer_token  = consumer_token
+      @consumer_secret = consumer_secret
+      @callback_url    = options[:callback_url]
+    end
+
+    def consumer
+      @consumer ||= ::OAuth::Consumer.new(@consumer_token, @consumer_secret, {
+        :site               => AWeber.auth_endpoint,
+        :request_token_path => "/#{AWeber::AUTH_VERSION}/oauth/request_token",
+        :authorize_path     => "/#{AWeber::AUTH_VERSION}/oauth/authorize",
+        :access_token_path  => "/#{AWeber::AUTH_VERSION}/oauth/access_token",
+        :scheme             => :query_string
+      })
+    end
+
+    # Retrieve a Request Token or simply return it, if it already exists.
+    #
+    # @param [Hash] options OAuth parameters. +:oauth_callback+ for example
+    #
+    def request_token(options={})
+      @request_token ||= consumer.get_request_token(options)
+    end
+
+    # Get an Access Token from a Request Token using the 
+    # +verifier+ code.
+    #
+    # @param [String] verifier Verification code retrieved from 
+    #                          user authentication
+    #
+    def authorize_with_verifier(verifier)
+      token = request_token.get_access_token(:oauth_verifier => verifier)
+      @access_token_key    = token.token
+      @access_token_secret = token.secret
+      access_token
+    end
+
+    def access_token
+      @access_token ||= ::OAuth::AccessToken.new(consumer, @access_token_key,
+        @access_token_secret)
+    end
+
+    # Authorize with an Access Token key and secret you've previously
+    # retrieved via a user authentication.
+    #
+    # @param [String] access_token_key Access Token key
+    # @param [String] access_token_secret Access Token secret
+    #
+    def authorize_with_access(access_token_key, access_token_secret)
+      @access_token_key    = access_token_key
+      @access_token_secret = access_token_secret
+    end
+
+    # Remove any active token instances and start over
+    #
+    def clear_tokens
+      @request_token = nil
+      @access_token  = nil
+    end
+  end
+end

data/lib/aweber/resource.rb

@@ -0,0 +1,131 @@
+module AWeber
+  # Base class for all entries. All resources have the following attributes:
+  #
+  # - +id+
+  # - +http_etag+ (aliased as +etag+)
+  # - +self_link+ (aliased as +link+)
+  # - +resource_type_link+ (aliased as +resource_type+)
+  #
+  # Resources also have attributes based on their the type of resource it is.
+  # To see a full list of attributes per resource, visit
+  # http://labs.aweber.com/docs/reference/1.0/reference.
+  #
+  class Resource
+    extend Forwardable
+    include Comparable
+
+    class << self
+      attr_accessor :writable_attrs
+      # Works the same as +alias_method+, but for attributes created via
+      # +attr*+ methods.
+      #
+      def alias_attribute(alias_, attribute)
+        alias_method alias_, attribute
+      end
+      
+      # Defines an attribute that it either read only or writable.
+      # 
+      # == Example:
+      # 
+      #   # Read-only
+      #   api_attr :name
+      # 
+      #   # Writable
+      #   api_attr :name, :writable => true
+      # 
+      # If an attribute is writable it will be sent with the request when
+      # +save+ is called.
+      # 
+      def api_attr(attr_, opts={})
+        if opts[:writable]
+          attr_accessor attr_
+          @writable_attrs ||= []
+          @writable_attrs << attr_
+        else
+          attr_reader attr_
+        end
+      end
+      
+      def has_one(name)
+        define_method(name) do
+          ivar = instance_variable_get("@#{name}")
+          return ivar if ivar
+          
+          resource_link = instance_variable_get("@#{name}_link")
+          klass         = AWeber.get_class(:"#{name}s")
+          collection    = klass.new(client, client.get(resource_link))
+          instance_variable_set("@#{name}", collection)
+        end
+      end
+
+      # Creates a lazy loaded method which will retrieve and create a 
+      # collection of +name+ of objects.
+      #
+      # @param [Symbol] name name of the collection method
+      # @return [AWeber::Collection] Collection of +name+ objects
+      #
+      # @example
+      #   class Account
+      #     attr_reader :lists_collection_link
+      #     collection  :lists
+      #   end
+      #
+      #   #=> Account.new(...).lists #=> <AWeber::Collection>
+      #
+      def has_many(name)
+        define_method(name) do
+          ivar = instance_variable_get("@#{name}")
+          return ivar if ivar
+
+          resource_link = instance_variable_get("@#{name}_collection_link")
+          klass         = AWeber.get_class(name)
+          collection    = Collection.new(client, klass, client.get(resource_link))
+          instance_variable_set("@#{name}", collection)
+        end
+      end
+    end
+
+    api_attr :id
+    api_attr :http_etag
+    api_attr :self_link
+    api_attr :resource_type_link
+
+    alias_attribute :etag, :http_etag
+    alias_attribute :link, :self_link
+    alias_attribute :resource_type, :resource_type_link
+
+    def initialize(client, data={})
+      @client = client
+      data.each do |key, value|
+        instance_variable_set("@#{key}", value) if respond_to? key
+      end
+    end
+    
+    def delete
+      client.delete(@self_link)
+    end
+    
+    def save
+      body = writable_attrs.inject({}) do |body, attr_|
+        body[attr_] = send(attr_)
+        body
+      end
+      client.put(self_link, body)
+    end
+    
+    def writable_attrs
+      self.class.writable_attrs ||= {}
+    end
+
+    def <=>(other)
+      @id <=> other.id
+    end
+
+  private
+
+    def client
+      @client
+    end
+
+  end
+end

data/lib/aweber/resources.rb

@@ -0,0 +1,14 @@
+require "aweber/resources/account"
+require "aweber/resources/broadcast"
+require "aweber/resources/click"
+require "aweber/resources/followup"
+require "aweber/resources/link"
+require "aweber/resources/list"
+require "aweber/resources/message"
+require "aweber/resources/open"
+require "aweber/resources/subscriber"
+require "aweber/resources/tracked_event"
+require "aweber/resources/integration"
+require "aweber/resources/web_form"
+require "aweber/resources/web_form_split_test"
+require "aweber/resources/web_form_split_test_component"

data/lib/aweber/resources/account.rb

@@ -0,0 +1,14 @@
+module AWeber
+  module Resources
+    class Account < Resource
+      api_attr :lists_collection_link
+      api_attr :integrations_collection_link
+    
+      has_many :lists
+      has_many :integrations
+    
+      alias_attribute :etag, :http_etag
+      alias_attribute :uri, :self_link
+    end
+  end
+end

data/lib/aweber/resources/broadcast.rb

@@ -0,0 +1,29 @@
+module AWeber
+  module Resources
+    class Broadcast < Resource
+      api_attr :click_tracking_enabled
+      api_attr :content_type
+      api_attr :is_archived
+      api_attr :scheduled_at
+      api_attr :sent_at
+      api_attr :spam_assassin_score
+      api_attr :subject
+      api_attr :total_clicks
+      api_attr :total_opens
+      api_attr :total_sent
+      api_attr :total_spam_complaints
+      api_attr :total_undelivered
+      api_attr :total_unsubscribes
+      api_attr :twitter_account_link
+
+      api_attr :links_collection_link
+      api_attr :messages_collection_link
+
+      has_many :links
+      has_many :messages
+
+      alias_attribute :is_archived?, :is_archived
+      alias_attribute :is_click_tracking_enabled?, :click_tracking_enabled
+    end
+  end
+end

data/lib/aweber/resources/click.rb

@@ -0,0 +1,13 @@
+module AWeber
+  module Resources
+    class Click < Resource
+      api_attr :event_time
+      api_attr :is_earliest
+      api_attr :subscriber_link
+      
+      has_one :subscriber
+      
+      alias_attribute :is_earliest?, :is_earliest
+    end
+  end
+end