open_auth2 0.0.8

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in villan.gemspec
+gemspec

data/License

@@ -0,0 +1,9 @@
+(The MIT License)
+
+Copyright (c) 2012, Senthil A. <senthil196@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software isfurnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,126 @@
+# Author:
+# Tom Preston-Werner part of his https://github.com/mojombo/rakegem
+#
+# Modified:
+# Senthil A
+
+require 'date'
+
+# Helper functions
+
+def name
+  @name ||= Dir['*.gemspec'].first.split('.').first
+end
+
+def version
+  line = File.read("lib/#{name}/version.rb")[/^\s*VERSION\s*=\s*.*/]
+  line.match(/.*VERSION\s*=\s*['"](.*)['"]/)[1]
+end
+
+def date
+  Date.today.to_s
+end
+
+def rubyforge_project
+  name
+end
+
+def gemspec_file
+  "#{name}.gemspec"
+end
+
+def gem_file
+  "open_auth2-#{version}.gem"
+end
+
+def replace_header(head, header_name)
+  head.sub!(/(\.#{header_name}\s*= ').*'/) { "#{$1}#{send(header_name)}'"}
+end
+
+# Standard tasks
+
+task :default => :spec
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rspec_opts = ['--backtrace']
+end
+
+desc "Generate SimpleCov test coverage and open in your browser"
+task :coverage do
+  sh "rake spec COVERAGE=true"
+  sh "open coverage/index.html"
+end
+
+desc "Open an irb session preloaded with this library"
+task :irb do
+  sh "irb -rubygems -r ./lib/#{name}.rb"
+end
+
+desc "Open a pry session preloaded with this library"
+task :pry do
+  sh "pry -r ./lib/#{name}.rb"
+end
+
+# Custom tasks (add your own tasks here)
+
+desc "Open a pry session with examples/fb loaded"
+task :fb do
+  sh "pry -r ./examples/fb.rb"
+end
+
+desc "Open a pry session with examples/google loaded"
+task :google do
+  sh "pry -r ./examples/google.rb"
+end
+
+# Packaging tasks
+
+desc "Create tag v#{version} and build and push #{gem_file} to Rubygems"
+task :release => :build do
+  unless `git branch` =~ /^\* master$/
+    puts "You must be on the master branch to release!"
+    exit!
+  end
+  sh "git commit --allow-empty -a -m 'Release #{version}'"
+  sh "git tag v#{version}"
+  sh "git push origin master"
+  sh "git push origin v#{version}"
+  sh "gem push pkg/open-auth2-#{version}.gem"
+end
+
+desc "Build #{gem_file} into the pkg directory"
+task :build => :gemspec do
+  sh "mkdir -p pkg"
+  sh "gem build #{gemspec_file}"
+  #sh "mv #{gem_file} pkg"
+end
+
+desc "Generate #{gemspec_file}"
+task :gemspec do
+  # read spec file and split out manifest section
+  spec = File.read(gemspec_file)
+  head, manifest, tail = spec.split("  # = MANIFEST =\n")
+
+  # replace name version and date
+  replace_header(head, :name)
+  replace_header(head, :version)
+  replace_header(head, :date)
+  #comment this out if your rubyforge_project has a different name
+  replace_header(head, :rubyforge_project)
+
+  # determine file list from git ls-files
+  files = `git ls-files`.
+    split("\n").
+    sort.
+    reject { |file| file =~ /^\./ }.
+    reject { |file| file =~ /^(rdoc|pkg)/ }.
+    map { |file| "    #{file}" }.
+    join("\n")
+
+  # piece file back together and write
+  manifest = "  s.files = %w[\n#{files}\n  ]\n"
+  spec = [head, manifest, tail].join("  # = MANIFEST =\n")
+  File.open(gemspec_file, 'w') { |io| io.write(spec) }
+  puts "Updated #{gemspec_file}"
+end

data/Readme.markdown

@@ -0,0 +1,235 @@
+# OpenAuth2 [![Build Status](https://secure.travis-ci.org/sent-hil/OpenAuth2.png?branch=master)][travis]
+
+[travis]: http://travis-ci.org/sent-hil/OpenAuth2
+
+OpenAuth2 is a thin OAuth2 wrapper written on top of Faraday in Ruby. The goal is a simple, well documented, easy to use interface for all your OAuth2 needs.
+
+* This software is alpha, you're either very brave or very foolish to use this in production of rockets or anything else.
+
+## Config
+
+To begin, let's setup the configuration. Here we're assuming connection to Facebook api. OpenAuth2 supports Google and Facebook out of the box (more to come soon). Other sites can be configured manually.
+
+```ruby
+require 'open_auth2'
+
+# get this info by signing your app at developers.facebook.com
+client_id     = 'enter in your own value'
+client_secret = 'enter in your own value'
+redirect_uri  = 'enter in your own value'
+
+config = OpenAuth2::Config.new do |c|
+  # indicate what kind of provider you want to use
+  # Accepts: :google, :facebook or :default
+
+  c.provider       = :facebook
+
+  c.client_id      = client_id
+  c.client_secret  = client_secret
+  c.redirect_uri   = redirect_uri
+  c.scope          = ['publish_stream']
+end
+```
+
+## Client
+
+Next, initialize a `client` object, which we'll use to make requests and pass in the `config` object we created earlier.
+
+```ruby
+client = OpenAuth2::Client.new do |c|
+  c.config = config
+end
+```
+
+`Client#connection` returns a `Faraday::Connection` object, which can be used to setup middleware.
+
+```ruby
+client.connection do
+  response :logger
+end
+```
+
+## Authenticate Url
+
+To start the OAuth2 exotic dance, you'll need to obtain a 'code' from the server, which you can then use to request an 'access_token'. Redirect the user/yourself to this url to obtain that 'code'.
+
+```ruby
+client.build_code_url
+```
+
+`build_code_url` takes optional params hash, which will be bundled into the url.
+
+```ruby
+client.build_code_url(:scope => 'publish_stream')
+```
+
+## Access token
+
+Access token is used to sign the request so the server can identify the client sending the request. If you already have an access token, add it to the client with a block.
+
+```ruby
+access_token  = 'enter in your value'
+refresh_token = 'enter in your value'
+
+client.configure do |c|
+  c.access_token  = access_token
+
+  # optional, for fb its same as above
+  c.refresh_token = refresh_token
+end
+```
+
+## GET Access Token
+
+If you don't have an access token, we'll need to ask the server for it.
+
+`token#configure` is similar to `client#connection`.
+
+```ruby
+token = client.token
+token.configure do
+  response :logger
+end
+
+# asks Facebook for access_token
+token.get
+
+# the following methods are now available
+client.access_token
+client.refresh_token
+client.token_expires_at
+client.token_expired?
+client.token_arrived_at
+```
+
+## GET Refresh Token
+
+```ruby
+# tells Facebook api to extend the expiration of the access_token
+token.refresh
+```
+
+## GET request
+
+To make an api call, simply call `get` with a hash containing `path`.
+
+```ruby
+client.get(:path => '/cocacola')
+```
+
+`get` accepts a Hash as second argument, which can be used to pass in additional parameters.
+
+```ruby
+client.get(:path => '/cocacola', :limit => 1)
+```
+
+## Faraday convenience methods
+
+`Client#get` is a convenience method that calls `Faraday#get`. You can drop down to Faraday connection object itself and make requests via that also.
+
+```ruby
+client.connection.get do |conn|
+  conn.url('/cocacola')
+end
+```
+
+`Client#run_request` points to `Faraday#run_request`. It takes hash since I can never remember the order in which to pass the arguments.
+
+```ruby
+path = "https://graph.facebook.com/cocacola"
+client.run_request(verb: :get, path: path, body: nil, header: nil)
+
+# same as
+client.connection.run_request(:get, path, nil, nil)
+```
+
+## Plugins
+
+Since various OAuth2 providers differ in their implementation, OpenAuth2 provides a simple plugin system to accomodate the differences, rather than 'one shoe fits all' approach. Facebook and Google plugins are builtin, but it is trivial to add new ones.
+
+There are only three requirements:
+
+  1. Should be under right namespace (OpenAuth2::Provider)
+  1. Should contain #options method
+  1. Should contain #parse method
+
+To use the plugin, call `Config#provider=` with name of the provider. OpenAuth2 upcases and camelizes the name and looks for the constant under OpenAuth2::Provider namespace.
+
+### Plugin Example
+
+```ruby
+module OpenAuth2
+  module Provider
+    class Default
+
+      # Provider::Base contains keys of various accepted Options,
+      # while Provider::Default contains the default options and
+      # their values. You can however override them here.
+      #
+      def options
+        {
+        :response_type            => 'code',
+        :access_token_grant_name  => 'authorization_code',
+        :refresh_token_grant_name => 'refresh_token',
+        :refresh_token_name       => :refresh_token,
+        :scope                    => [],
+        }
+      end
+
+      # Called after AccessToken#get and #refresh response are received
+      # from provider.
+      #
+      def parse(config, response_body)
+        # parse the response body
+        access_token            = response_body.gsub('access_token=', '')
+
+        # update config to reflect new information
+        config.access_token     = access_token
+        config.token_arrived_at = Time.now
+      end
+    end
+  end
+end
+```
+
+## Examples
+
+See examples/ for more ... (its a surprise).
+
+## Requirements
+
+  * ActiveSupport
+  * Faraday
+  * URI
+  * Json
+
+## Supported Versions
+
+  * MRI 1.9.2
+  * MRI 1.9.3
+  * jRuby (jruby --1.9 rspec)
+  * Rubinius 2.0.0dev (RBXOPT=-X19 rbx- S rspec)
+
+## Install
+
+    $ gem install open_auth2
+
+## Source
+
+OpenAuth2's git repo is available on GitHub:
+
+    https://github.com/senthilnambi/OpenAuth2
+
+## Development
+
+You will need these gems to get tests to pass:
+
+  * rspec2
+  * rake
+  * SimpleCov (optional for coverage)
+
+See [meta](https://github.com/senthilnambi/meta) for more info on contributing and technology used to create this gem.
+
+## Copyright
+
+Copyright (c) 2012 Senthil A. See License for details.

data/examples/fb.rb

@@ -0,0 +1,20 @@
+require_relative '../lib/open_auth2'
+
+ClientId = '216091171753850'
+ClientSecret = '56f751bef00d6d21e858566b873ac8f8'
+Code = ''
+AccessToken = ''
+
+@config = OpenAuth2::Config.new do |c|
+  c.provider       = :facebook
+  c.client_id      = ClientId
+  c.client_secret  = ClientSecret
+  c.code           = Code
+  c.access_token   = AccessToken
+  c.redirect_uri   = 'http://localhost:9393/'
+  c.scope          = ['manage_pages', 'read_insights']
+end
+
+@client = OpenAuth2::Client.new(@config)
+@url    = @client.build_code_url
+@token  = @client.token

data/examples/google.rb

@@ -0,0 +1,57 @@
+require_relative '../lib/open_auth2'
+require 'json'
+
+ClientId     = '948773240950.apps.googleusercontent.com'
+ClientSecret = 'MTkeuqOhFTbfRbd27BcEROTl'
+Code         = nil
+AccessToken  = 'ya29.AHES6ZRL6dKYn5HvssNQvH15KXTc76jCd9KC6Wfsir74whQ'
+RefreshToken = '1/2hTXHN9FULj7v_hVOIoyHn6BpOQS6uDOw-xllInXnTU'
+PostEmail    = 'senthil196@gmail.com'
+
+@config = OpenAuth2::Config.new do |c|
+  c.provider       = :google
+  c.code           = Code
+  c.client_id      = ClientId
+  c.client_secret  = ClientSecret
+  c.access_token   = AccessToken
+  c.refresh_token  = RefreshToken
+  c.scope          = ['https://www.googleapis.com/auth/calendar']
+  c.redirect_uri   = 'http://localhost:9393/google/callback'
+  c.path_prefix    = '/calendar/v3'
+end
+
+@client = OpenAuth2::Client.new do |c|
+  c.config = @config
+end
+
+#@token = @client.token
+
+#params = {:approval_prompt => 'force', :access_type => 'offline'}
+#@url  = @token.build_code_url(params)
+
+# get request
+@list = @client.get(:path => '/users/me/calendarList')
+
+@post_url = "/calendar/v3/calendars/#{PostEmail}/events"
+@body     = {
+  "summary" => "From OpenAuth2",
+  "start"   => {"dateTime"=>"2012-10-03T10:00:00.000-07:00"},
+  "end"     => {"dateTime"=>"2012-10-03T10:25:00.000-07:00"}
+}
+@body = JSON.dump(@body)
+
+# post request
+def make_request
+  @response  = @client.post(:path         => @post_url,
+                            :body         => @body,
+                            :content_type => "application/json")
+end
+
+#header   = {"Content-Type" => "application/json"}
+#full_url = "#{post_url}?access_token=#{AccessToken}"
+
+# post request via #run_request
+#@client.run_request(:verb   => :post,
+                    #:path   => full_url,
+                    #:body   => body,
+                    #:header => header)

data/lib/open_auth2/client.rb

@@ -0,0 +1,184 @@
+module OpenAuth2
+
+  # Makes GET/POST requests to OAuth server.
+  class Client
+    extend DelegateToConfig
+
+    attr_accessor :faraday_url
+
+    # Use to set config.
+    #
+    # 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)
+    #
+    def initialize(config=nil)
+      @config = config
+      yield self if block_given?
+      @faraday_url = endpoint
+    end
+
+    # Use to set/change config after #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 if block_given?
+    end
+
+    # 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. 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.
+    #
+    # 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
+
+    # 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