OpenAuth2 0.0.1

data/lib/open_auth2/client.rb

@@ -0,0 +1,182 @@
+module OpenAuth2
+
+  # Used to make GET/POST requests to OAuth server.
+  class Client
+    extend DelegateToConfig
+    include Connection
+
+    # Use it to set @config. Will raise error if no @config or wrong
+    # @config. We rely on Config for all Options info, so its important
+    # it is set right.
+    #
+    # Yields: self.
+    #
+    # Accepts:
+    #   config: (optional) OpenAuth2::Config object
+    #
+    # Examples:
+    #   config = OpenAuth2::Config.new do |c|
+    #     c.provider = :facebook
+    #   end
+    #
+    #   # set via block
+    #   OpenAuth2::Client.new do |c|
+    #     c.config = config
+    #   end
+    #
+    #   # or pass it as an argument
+    #   OpenAuth2::Client.new(config)
+    #
+    # Returns: self.
+    #
+    def initialize(config=nil)
+      @config = config
+
+      yield self if block_given?
+      raise_config_setter_errors
+
+      # endpoint is where the api requests are made
+      @faraday_url = endpoint
+
+      self
+    end
+
+    # Yields: self, use it to set/change config after #initialize.
+    # Mainly for setting access_token and refresh_token. Will raise
+    # Config related errors same as #initialize.
+    #
+    # Examples:
+    #   client = OpenAuth2::Client.new
+    #
+    #   client.configure do |c|
+    #     c.access_token  = :access_token
+    #     c.refresh_token = :refresh_token
+    #   end
+    #
+    # Returns: self.
+    #
+    def configure
+      yield self
+      raise_config_setter_errors
+
+      self
+    end
+
+    # We use this to get & refresh access/refresh tokens.
+    #
+    # Returns: Token object.
+    #
+    def token
+      @token ||= Token.new(config)
+    end
+
+    # Examples:
+    #   client.build_code_url
+    #   #=> 'http://...'
+    #
+    #   # or
+    #   client.build_code_url(:scope => 'publish_stream')
+    #
+    # Accepts:
+    #   params: (optional) Hash of additional config to be bundled into
+    #           the url.
+    #
+    # Returns: String (url).
+    #
+    def build_code_url(params={})
+      token.build_code_url(params)
+    end
+
+    # Makes GET request to OAuth server via Faraday. If access_token
+    # is available, we pass that along to identify ourselves.
+    #
+    # Accepts:
+    #   hash
+    #     :path - (required)
+    #
+    # Examples:
+    #   client.get(:path => '/cocacola')
+    #   client.get(:path => '/cocacola', :limit => 1)
+    #
+    # Returns: Faraday response object.
+    #
+    def get(hash)
+      connection.get do |conn|
+        path = hash.delete(:path)
+
+        if path_prefix
+          path = "#{path_prefix}#{path}"
+        end
+
+        hash.merge!(:access_token => access_token) if access_token
+
+        conn.url(path, hash)
+      end
+    end
+
+    # Makes POST request to OAuth server via Faraday.
+    #
+    # Accepts:
+    #   hash
+    #     :path         - (required)
+    #     :content_type - (optional)
+    #     :body         - (optional)
+    #
+    # Examples:
+    #   # using query params (fb uses this)
+    #   client.post(:path => "/me/feed?message='From OpenAuth2'")
+    #
+    #   # using body (google uses this)
+    #   body = JSON.dump(:message => "From OpenAuth2)
+    #   client.post(:path         => "/me/feed,
+    #               :body         => body,
+    #               :content_type => 'application/json')
+    #
+    # Returns: Faraday response object.
+    #
+    def post(hash)
+      connection.post do |conn|
+        if hash[:content_type]
+          conn.headers["Content-Type"] = hash[:content_type]
+        end
+
+        conn.url(hash[:path], :access_token => access_token)
+        conn.body = hash[:body]
+      end
+    end
+
+    # Makes request to OAuth server via Faraday#run_request. It takes
+    # Hash since I can never remember the order in which to pass the
+    # arguments.
+    #
+    # Accepts:
+    #   hash
+    #     :verb   - (required) GET/POST etc.
+    #     :path   - (required)
+    #     :body   - (optional)
+    #     :header - (optional)
+    #
+    # Examples:
+    #   # public GET request
+    #   path = "https://graph.facebook.com/cocacola"
+    #   client.run_request(verb: :get, path: path, body: nil, header: nil)
+    #
+    #   # private GET request
+    #   path = "/me/likes?access_token=..."
+    #   client.run_request(verb: :get, path: path, body: nil, header: nil)
+    #
+    # Returns: Faraday response object.
+    #
+    def run_request(hash)
+      connection.run_request(hash[:verb], hash[:path], hash[:body],
+                             hash[:header])
+    end
+
+    private
+
+    def raise_config_setter_errors
+      raise NoConfigObject      unless config
+      raise UnknownConfigObject unless config.is_a?(OpenAuth2::Config)
+    end
+  end
+end

data/lib/open_auth2/config.rb

@@ -0,0 +1,102 @@
+module OpenAuth2
+
+  # Holds the info required to make a valid request to an OAuth server.
+  class Config
+    attr_accessor *Provider::Base::Keys
+    attr_reader :provider, :provider_const, :provider_string
+
+    # Sets provider to default.
+    #
+    # Yields: self, use it to set config.
+    #
+    # Examples:
+    #   OpenAuth2::Config.new do |c|
+    #     c.provider = :default
+    #   end
+    #
+    # Returns: self.
+    #
+    def initialize
+      set_default_as_provider
+
+      yield self if block_given?
+    end
+
+    # Yields: self, use it to set/change config after #initialize.
+    #
+    # Examples:
+    #   config = OpenAuth2::Config.new
+    #
+    #   config.configure do |c|
+    #     c.provider = :google
+    #   end
+    #
+    # Returns: self.
+    #
+    def configure
+      yield self if block_given?
+    end
+
+    # Finds provider's module & copies its Options key/values to here.
+    #
+    # Accepts:
+    #   name - String/Symbol/Constant.
+    #
+    def provider=(name)
+      set_provider_vars(name)
+      copy_provider_keys
+    end
+
+    # Removes all overwritten config & resets provider to default.
+    def reset_provider
+      remove_instance_vars
+      set_default_as_provider
+    end
+
+    def parse(response_body)
+      @provider_const.parse(self, response_body)
+    end
+
+    private
+
+    def set_default_as_provider
+      self.provider = :default
+    end
+
+    def set_provider_vars(name)
+      @provider        = name
+      @provider_string = name.to_s
+      @provider_const  = constantize_provider_string
+    end
+
+    def constantize_provider_string
+      provider_string = @provider_string.camelize
+      full_string     = "OpenAuth2::Provider::#{provider_string}"
+
+      @provider_const = full_string.constantize
+    rescue NameError => error
+      if error.to_s =~ /uninitialized constant/
+        raise UnknownProvider, "Known Providers: #{known_providers}"
+      end
+    end
+
+    def known_providers
+      known_providers = OpenAuth2::Provider.constants
+      known_providers.delete(:Base)
+
+      known_providers
+    end
+
+    def copy_provider_keys
+      @provider_const::Options.each do |key,value|
+        instance_variable_set("@#{key}", value)
+      end
+    end
+
+    def remove_instance_vars
+      instance_variables.each do |var|
+        remove_instance_variable var
+      end
+    end
+  end
+end

data/lib/open_auth2/connection.rb

@@ -0,0 +1,38 @@
+module OpenAuth2
+
+  # Client/Token use this to make the actual requests to OAuth server.
+  # Since some OAuth servers have seperate endpoints for authorization
+  # & api requests, we use @faraday_url to store that info.
+  #
+  module Connection
+    def self.included(base)
+      base.class_eval do
+        attr_accessor :faraday_url
+      end
+    end
+
+    # Yields: Faraday object, so user can choose choose their own
+    # middleware.
+    #
+    # Examples:
+    #   config = OpenAuth2::Config.new
+    #   client = OpenAuth2::Client.new(config)
+    #
+    #   client.connection do |c|
+    #     c.response :logger
+    #   end
+    #
+    # Returns: Faraday object.
+    #
+    def connection
+      @connection ||= Faraday.new(:url => @faraday_url) do |builder|
+        builder.request :url_encoded
+        builder.adapter :net_http
+      end
+
+      yield @connection if block_given?
+
+      @connection
+    end
+  end
+end

data/lib/open_auth2/delegate_to_config.rb

@@ -0,0 +1,25 @@
+module OpenAuth2
+
+  # Helper module that Client/Token extend so they can have access to
+  # Options methods. We delegate those methods to @config, which should
+  # contain Config object.
+  #
+  module DelegateToConfig
+    def self.extended(base)
+      base.send(:attr_accessor, :config)
+      base.delegate_to_config
+    end
+
+    def delegate_to_config
+      OpenAuth2::Provider::Base::Keys.each do |key|
+        define_method(key) do
+          @config.send(key)
+        end
+
+        define_method("#{key}=") do |value|
+          @config.send("#{key}=", value)
+        end
+      end
+    end
+  end
+end

data/lib/open_auth2/provider.rb

@@ -0,0 +1,21 @@
+# Contains various providers & their config info stored in Options hash.
+# When user sets a provider, we copy over its Options to Config.
+#
+# The reason for this setup is b/c various OAuth servers accept &
+# return different options & values. This way users can contribute
+# their own providers, i.e. a very simple plugin system.
+#
+# Acceptable providers are modules defined under OpenAuth2::Provider,
+# have Options hash.
+#
+# Examples:
+#   module OpenAuth2::Providers::YourProviderName
+#     Options = {
+#       :authorize_url => 'https://your_provider_name.com'
+#     }
+#   end
+#
+module OpenAuth2
+  module Provider
+  end
+end

data/lib/open_auth2/provider/base.rb

@@ -0,0 +1,31 @@
+module OpenAuth2
+  module Provider
+
+    # Contains all possible Options keys. Config allows only the ones
+    # specified here.
+    #
+    module Base
+      Keys = [
+        :client_id,
+        :client_secret,
+        :code,
+        :authorize_url,
+        :redirect_uri,
+        :code_url,
+        :authorize_path,
+        :token_path,
+        :access_token,
+        :refresh_token,
+        :response_type,
+        :access_token_grant_name,
+        :refresh_token_grant_name,
+        :refresh_token_name,
+        :scope,
+        :endpoint,
+        :path_prefix,
+        :token_expires_at,
+        :token_arrived_at,
+      ]
+    end
+  end
+end

data/lib/open_auth2/provider/default.rb

@@ -0,0 +1,18 @@
+module OpenAuth2
+  module Provider
+
+    # Contains the default Options, which is copied to Config on
+    # #initialize. We can then choose another provider or overwrite
+    # them individually.
+    #
+    module Default
+      Options = {
+        :response_type            => 'code',
+        :access_token_grant_name  => 'authorization_code',
+        :refresh_token_grant_name => 'refresh_token',
+        :refresh_token_name       => :refresh_token,
+        :scope                    => [],
+      }
+    end
+  end
+end

data/lib/open_auth2/provider/facebook.rb

@@ -0,0 +1,23 @@
+module OpenAuth2
+  module Provider
+    module Facebook
+      Options = {
+        :authorize_url            => 'https://graph.facebook.com',
+        :code_url                 => 'https://www.facebook.com',
+        :refresh_token_grant_name => 'fb_exchange_token',
+        :refresh_token_name       => 'fb_exchange_token',
+        :authorize_path           => '/dialog/oauth',
+        :token_path               => 'oauth/access_token',
+        :endpoint                 => 'https://graph.facebook.com'
+      }
+
+      def self.parse(config, response_body)
+        access_token            = response_body.gsub('access_token=', '')
+        config.access_token     = access_token
+        config.refresh_token    = access_token
+        config.token_arrived_at = Time.now
+        config.token_expires_at = "60 days?"
+      end
+    end
+  end
+end