open_auth2 0.0.8

data/lib/open_auth2/config.rb

@@ -0,0 +1,95 @@
+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
+
+    # Use to set config info.
+    #
+    # Examples:
+    #   OpenAuth2::Config.new do |c|
+    #     c.provider = :default
+    #   end
+    #
+    def initialize
+      set_default_as_provider
+      yield self if block_given?
+    end
+
+    # Use to set config info.
+    #
+    # 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/value pairs.
+    #
+    # Accepts:
+    #   name - String/Symbol/Constant.
+    #
+    def provider=(name)
+      set_provider_vars(name)
+      copy_provider_keys
+    end
+
+    # Removes all overwritten config & reset to default.
+    def reset_provider
+      remove_instance_vars
+      set_default_as_provider
+    end
+
+    def parse(response_body)
+      @provider_const.new.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
+      raise UnknownProvider, "Known Providers: #{known_providers}"
+    end
+
+    def known_providers
+      known_providers = OpenAuth2::Provider.constants
+      known_providers.delete(:Base)
+
+      known_providers
+    end
+
+    def copy_provider_keys
+      @provider_const::new.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,37 @@
+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
+    #     response :logger
+    #   end
+    #
+    # Returns: Faraday object.
+    #
+    def connection(&blk)
+      @connection ||= Faraday.new(:url => @faraday_url) do |builder|
+        builder.request :url_encoded
+        builder.adapter :net_http
+        builder.instance_eval(&blk) if block_given?
+      end
+
+      @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/base.rb

@@ -0,0 +1,31 @@
+module OpenAuth2
+  module Provider
+
+    # Contains all possible Options keys. Config uses this to define
+    # methods.
+    #
+    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,24 @@
+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.
+    #
+    class Default
+      def options
+        {
+        :response_type            => 'code',
+        :access_token_grant_name  => 'authorization_code',
+        :refresh_token_grant_name => 'refresh_token',
+        :refresh_token_name       => :refresh_token,
+        :scope                    => [],
+        }
+      end
+
+      def parse(config, response_body)
+        response_body
+      end
+    end
+  end
+end

data/lib/open_auth2/provider/facebook.rb

@@ -0,0 +1,25 @@
+module OpenAuth2
+  module Provider
+    class Facebook
+      def 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'
+        }
+      end
+
+      def 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

data/lib/open_auth2/provider/google.rb

@@ -0,0 +1,30 @@
+module OpenAuth2
+  module Provider
+    class Google
+      def options
+        {
+        :authorize_url  => 'https://accounts.google.com',
+        :code_url       => 'https://accounts.google.com',
+        :authorize_path => '/o/oauth2/auth',
+        :redirect_uri   => 'http://localhost:9393/google/callback',
+        :token_path     => '/o/oauth2/token',
+        :endpoint       => 'https://www.googleapis.com'
+        }
+      end
+
+      def parse(config, body)
+        json                    = JSON.parse(body)
+
+        config.access_token     = json['access_token']
+        config.token_arrived_at = Time.now
+        config.token_expires_at = Time.now+3600
+
+        # google sends refresh_token when getting access_token, but not
+        # when refreshing
+        unless config.refresh_token
+          config.refresh_token = json['refresh_token']
+        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/token.rb

@@ -0,0 +1,126 @@
+require_relative 'client'
+
+module OpenAuth2
+
+  # Gets Access/Refresh tokens from OAuth server.
+  class Token < Client
+    def initialize(config)
+      @config      = config
+      @faraday_url = authorize_url
+    end
+
+    # Packages info from config & passed in arguments into an url that
+    # user can to visit to authorize this app.
+    #
+    # Examples:
+    #   token.build_code_url
+    #   #=> 'http://...'
+    #
+    #   # or
+    #   token.build_code_url(:scope => 'publish_stream')
+    #
+    # Accepts:
+    #   params - (optional) Hash of additional config.
+    #
+    # Returns: String (url).
+    #
+    def build_code_url(params={})
+      url = URI::HTTPS.build(:host  => host,
+                             :path  => authorize_path,
+                             :query => encoded_body(params))
+      url.to_s
+    end
+
+    # Makes request to OAuth server for access token & parses it by
+    # delegating to the appropriate provider.
+    #
+    # Accepts:
+    #   params - (optional) Hash of additional config to be sent with
+    #                       request.
+    #
+    def get(params={})
+      body        = get_body_hash(params)
+      raw_request = post(body)
+
+      parse(raw_request)
+    end
+
+    # Makes request to OAuth server to refresh the access token.
+    #
+    # Accepts:
+    #   params - (optional) Hash of additional config to be sent with
+    #                       request.
+    #
+    def refresh(params={})
+      body        = refresh_body_hash(params)
+      raw_request = post(body)
+
+      parse(raw_request)
+    end
+
+    def token_expired?
+      token_expires_at > Time.now
+    rescue
+      nil
+    end
+
+    private
+
+    # We use URI#parse to get rid of those pesky extra /.
+    def host
+      URI.parse(code_url).host
+    end
+
+    def encoded_body(params)
+      URI.encode_www_form(url_body_hash(params))
+    end
+
+    # Combine default options & user arguments.
+    def url_body_hash(params)
+
+      # user can define scope as String or Array
+      joined_scope = scope.join(',') if scope.respond_to?(:join)
+
+      {
+        :response_type => response_type,
+        :client_id     => client_id,
+        :redirect_uri  => redirect_uri,
+        :scope         => joined_scope
+      }.merge(params)
+    end
+
+    def get_body_hash(params)
+      {
+        :client_id      => client_id,
+        :client_secret  => client_secret,
+        :code           => code,
+        :grant_type     => access_token_grant_name,
+        :redirect_uri   => redirect_uri
+      }.merge(params)
+    end
+
+    def refresh_body_hash(params)
+       {
+         :client_id         => client_id,
+         :client_secret     => client_secret,
+         :grant_type        => refresh_token_grant_name,
+         refresh_token_name => refresh_token
+       }.merge(params)
+    end
+
+    # Makes the actual request. `connection` is a Faraday object.
+    def post(body)
+      connection.post do |conn|
+        conn.headers["Content-Type"] = "application/x-www-form-urlencoded"
+        conn.headers["Accept"]       = "application/json"
+        conn.url(token_path)
+        conn.body = body
+      end
+    end
+
+    def parse(response)
+      @config.parse(response.body)
+      response
+    end
+  end
+end

data/lib/open_auth2/version.rb

@@ -0,0 +1,3 @@
+module OpenAuth2
+  VERSION = '0.0.8'
+end

data/lib/open_auth2.rb

@@ -0,0 +1,23 @@
+require 'active_support/inflector'
+require 'faraday'
+require 'uri'
+require 'json'
+
+require_relative 'open_auth2/provider'
+require_relative 'open_auth2/provider/base'
+require_relative 'open_auth2/provider/default'
+require_relative 'open_auth2/provider/facebook'
+require_relative 'open_auth2/provider/google'
+
+require_relative 'open_auth2/delegate_to_config'
+require_relative 'open_auth2/config'
+#require_relative 'open_auth2/config'
+require_relative 'open_auth2/connection'
+require_relative 'open_auth2/token'
+require_relative 'open_auth2/client'
+
+require_relative 'open_auth2/version'
+
+module OpenAuth2
+  class UnknownProvider < StandardError; end
+end

data/open_auth2.gemspec

@@ -0,0 +1,80 @@
+# -*- encoding: utf-8 -*-
+require './lib/open_auth2/version'
+
+Gem::Specification.new do |s|
+  s.name              = "open_auth2"
+  s.version           = OpenAuth2::VERSION
+  s.authors           = ["sent-hil"]
+  s.email             = ["me@sent-hil.com"]
+  s.homepage          = "https://github.com/sent-hil/OpenAuth2"
+  s.description       = %q{OpenAuth2 is a simple OAuth2 client.}
+  s.summary           = %q{OpenAuth2 is a simple OAuth2 client written on top of Faraday in Ruby. The goal is a simple, well documented, easy to use interface for all your OAuth2 needs.}
+
+  s.rubyforge_project = "OpenAuth2"
+
+  s.files             = `git ls-files`.split("\n")
+  s.test_files        = `git ls-files -- spec/*`.split("\n")
+  s.executables       = `git ls-files -- bin/*`.split("\n").map do |f|
+    File.basename(f)
+  end
+
+  s.require_paths     = ["lib"]
+
+  s.add_dependency 'faraday',             '~> 0.7'
+  s.add_dependency 'activesupport',       '~> 3.1'
+  s.add_dependency 'json'
+
+  if RUBY_PLATFORM == 'java'
+    s.add_dependency 'json'
+    s.add_dependency 'jruby-openssl'
+  end
+
+  s.add_development_dependency 'rake',    '~> 0.9'
+  s.add_development_dependency 'rspec',   '~> 2.8'
+  s.add_development_dependency 'vcr',     '1.11.3'
+  s.add_development_dependency 'fakeweb', '~> 1.3'
+  s.add_development_dependency 'timecop', '~> 0.3'
+
+  # = MANIFEST =
+  s.files = %w[
+    Gemfile
+    License
+    Rakefile
+    Readme.markdown
+    Spec.markdown
+    examples/fb.rb
+    examples/google.rb
+    lib/open_auth2.rb
+    lib/open_auth2/client.rb
+    lib/open_auth2/config.rb
+    lib/open_auth2/connection.rb
+    lib/open_auth2/delegate_to_config.rb
+    lib/open_auth2/provider.rb
+    lib/open_auth2/provider/base.rb
+    lib/open_auth2/provider/default.rb
+    lib/open_auth2/provider/facebook.rb
+    lib/open_auth2/provider/google.rb
+    lib/open_auth2/token.rb
+    lib/open_auth2/version.rb
+    open_auth2.gemspec
+    spec/client_spec.rb
+    spec/config_spec.rb
+    spec/facebook/client_spec.rb
+    spec/facebook/token_spec.rb
+    spec/fixtures/creds.rb
+    spec/fixtures/vcr/fb/access_token.yml
+    spec/fixtures/vcr/fb/cocacola.yml
+    spec/fixtures/vcr/fb/me.yml
+    spec/fixtures/vcr/fb/post.yml
+    spec/fixtures/vcr/fb/refresh_token.yml
+    spec/fixtures/vcr/goog/access_token.yml
+    spec/fixtures/vcr/goog/list.yml
+    spec/fixtures/vcr/goog/post.yml
+    spec/fixtures/vcr/goog/refresh_token.yml
+    spec/google/client_spec.rb
+    spec/google/token_spec.rb
+    spec/spec_helper.rb
+    spec/token_spec.rb
+  ]
+  # = MANIFEST =
+end

data/spec/client_spec.rb

@@ -0,0 +1,92 @@
+require 'open_auth2'
+require 'spec_helper'
+
+describe OpenAuth2::Client do
+  let(:config) do
+    OpenAuth2::Config.new do |c|
+      c.provider     = :facebook
+      c.access_token = :access_token
+    end
+  end
+
+  subject do
+    described_class.new(config)
+  end
+
+  context '#initialize' do
+    it 'accepts config as an argument' do
+      subject.config.should == config
+    end
+
+    it 'accepts config via block' do
+      subject = described_class.new do |c|
+        c.config = config
+      end
+
+      subject.config.should == config
+    end
+
+    it 'sets endpoint to make requests' do
+      subject.faraday_url.should == 'https://graph.facebook.com'
+    end
+  end
+
+  context '#configure' do
+    it 'accepts a block to set/overwrite config' do
+      subject.configure do |c|
+        c.access_token  = :access_token
+        c.refresh_token = :refresh_token
+      end
+
+      subject.access_token.should  == :access_token
+      subject.refresh_token.should == :refresh_token
+    end
+  end
+
+  context '#token' do
+    it 'returns OpenAuth2::Token object' do
+      subject.token.should be_an(OpenAuth2::Token)
+    end
+  end
+
+  context '#build_code_url' do
+    it 'delegates to OpenAuth2::Token' do
+      OpenAuth2::Token.any_instance.should_receive(:build_code_url)
+      subject.build_code_url
+    end
+  end
+
+  subject { described_class.new(config) }
+
+  context OpenAuth2::DelegateToConfig do
+    it 'delegates Options getter methods' do
+      subject.authorize_url.should == 'https://graph.facebook.com'
+    end
+
+    it 'delegates Options setter methods' do
+      url = 'http://facebook.com'
+      subject.authorize_url = url
+
+      subject.authorize_url.should == url
+    end
+
+    it 'overwritten Options stays that way' do
+      config.access_token.should == :access_token
+    end
+  end
+
+  context OpenAuth2::Connection do
+    it 'returns Faraday object' do
+      subject.connection.should be_a(Faraday::Connection)
+    end
+
+    it 'allows adding custom middleware to Faraday' do
+      subject.connection do
+        response :logger
+      end
+
+      subject.connection.builder.handlers.should
+        include(Faraday::Response::Logger)
+    end
+  end
+end