playlyfe 0.2.2 → 0.4.5

data/lib/playlyfe.rb

@@ -1,86 +1,202 @@
+require 'uri'
 require 'json'
-require 'error'
-require 'client'
-require 'base'
-require 'strategy'
-require 'client_credentials'
-require 'access_token'
-require 'response'
+require 'rest_client'
 
-class Playlyfe
-  @@client = nil
-  @@token = nil
-  @@api = 'http://api.playlyfe.com/v1'
-  @@player = ""
-  @@debug = true
-
-  def self.token
-    @@token
+class PlaylyfeError < StandardError
+  attr_accessor :name, :message
+  def initialize(res)
+    message = []
+    begin
+      res = JSON.parse(res)
+      @name = res['error']
+      @message = res['error_description']
+      message << "#{@code}: #{@description}"
+    rescue => e
+    end
+    super(message.join("\n"))
   end
+end
+
+class Playlyfe
+  @@api = 'https://api.playlyfe.com/v1'
 
   # You can initiate a client by giving the client_id and client_secret params
   # This will authorize a client and get the token
+  #
+  # @param [Hash] options the options to make the request with
+  # @param options
+  #    [Boolean] :type where where type can be 'code', 'client' for
+  #       for the oauth2 auth code flow and client credentials flow
+  #    [lambda] :store a method that persists the access_token into
+  #       a database
+  #    [lambda] :retrieve a method that is used by the sdk internally
+  #       to read the access_token and use it in all your requests
   def self.init(options = {})
     puts 'Playlyfe Initializing...............................................'
+    if options[:type].nil?
+      err = PlaylyfeError.new("")
+      err.name = 'init_failed'
+      err.message = "You must pass in a type whether 'client' for client credentials flow or 'code' for auth code flow"
+      raise err
+    end
+    @@type = options[:type]
+    @@id = options[:client_id]
+    @@secret = options[:client_secret]
+    @@store = options[:store]
+    @@retrieve = options[:retrieve]
+    if @@store.nil?
+      @@store = lambda { |token| puts 'Storing Token' }
+    end
+    if @@type == 'client'
+      self.get_access_token()
+    else
+      if options[:redirect_uri].nil?
+        err = PlaylyfeError.new("")
+        err.name = 'init_failed'
+        err.message = 'You must pass in a redirect_uri for the auth code flow'
+        raise err
+      else
+        puts 'CLIENT'
+        #RestClient.get("https://playlyfe.com/auth?redirect_uri=#{options[:redirect_uri]}&response_type=code&client_id=#{@@id}")
+        #:authorize_url =>
+        #'response_type' => 'code', 'client_id' => @@id
+        #auth_url = @@client.auth_code.authorize_url(:redirect_uri => 'http://localhost:8080/oauth2/callback')
+        #@@client.auth_code.get_token('code_value', :redirect_uri => 'http://localhost:8080/oauth2/callback') #check query.code then make post request
+      end
+    end
+    #RestClient.log = Logger.new(STDOUT)
+  end
+
+  def self.get_access_token
+    puts 'Getting Access Token'
     begin
-      @@client = OAuth2::Client.new(
-          options[:client_id],
-          options[:client_secret],
-          :authorize_url => "/auth",
-          :token_url => "/auth/token",
-          :site => "http://playlyfe.com"
+      access_token = RestClient.post('https://playlyfe.com/auth/token',
+        {
+          :client_id => @@id,
+          :client_secret => @@secret,
+          :grant_type => 'client_credentials'
+        }.to_json,
+        :content_type => :json,
+        :accept => :json
       )
-    rescue OAuth2::Error => e
-      puts 'OAuth2 Error---------------------------------------'
-      puts
-      puts e
+      access_token = JSON.parse(access_token)
+      expires_at ||= Time.now.to_i + access_token['expires_in']
+      access_token.delete('expires_in')
+      access_token['expires_at'] = expires_at
+      @@store.call access_token
+      if @@retrieve.nil?
+        @@retrieve = lambda { return access_token }
+      end
+    rescue => e
+      raise PlaylyfeError.new(e.response)
+    end
+  end
+
+  def self.check_expired(access_token)
+    if access_token['expires_at'] < Time.now.to_i
+      puts 'Access Token Expired'
+      self.get_access_token()
     end
-    create_token()
   end
 
-  def self.create_token
-    @@token = @@client.client_credentials.get_token({}, {'auth_scheme' => 'request_body', 'mode' => 'query'})
+  # def refresh!(params = {})
+  #   params.merge!(:client_id => @client.id,
+  #                 :client_secret => @client.secret,
+  #                 :grant_type => 'refresh_token',
+  #                 :refresh_token => refresh_token)
+  #   new_token = @client.get_token(params)
+  #   new_token.options = options
+  #   new_token.refresh_token = refresh_token unless new_token.refresh_token
+  #   new_token
+  # end
+
+  def self.login
   end
 
   def self.get(options = {})
-    options[:player] ||= ''
-    options[:query] ||= ''
+    options[:route] ||= ''
+    options[:query] ||= {}
     options[:raw] ||= false
+
+    access_token = @@retrieve.call
+    self.check_expired(access_token)
+    options[:query][:access_token] = access_token['access_token']
+
     begin
-      response = @@token.get("#{@@api}#{options[:url]}?debug=true&player_id=#{options[:player]}&#{options[:query]}")
+      res = RestClient.get("#{@@api}#{options[:route]}",
+        {:params => options[:query] }
+      )
       if options[:raw] == true
-        return response
-      end
-      json = JSON.parse(response.body)
-      if @@debug
-        puts "Playlyfe: GET #{@@api}#{options[:url]}?debug=true&player_id=#{options[:player]}&#{options[:query]}"
-        puts
-        puts json
-      end
-      return json
-    rescue OAuth2::Error => e
-      puts 'OAuth2 Error'
-      puts e.code
-      puts e.description
-      if e.code == 'invalid_token'
-        create_token()
-        get()
+        return res.body
+      else
+        return JSON.parse(res.body)
       end
+    rescue => e
+      raise PlaylyfeError.new(e.response)
     end
   end
 
   def self.post(options = {})
-    options[:player] ||= ''
-    opts = {}
-    opts[:headers] ||= {'Content-Type' => 'application/json'}
-    opts[:body] = JSON.generate(options[:body])
-    response = @@token.post("#{@@api}#{options[:url]}?debug=true&player_id=#{options[:player]}", opts)
-    json = JSON.parse(response.body)
-    if @@debug
-      puts "Playlyfe: POST #{@@api}#{options[:url]}?debug=true&player_id=#{options[:player]}"
-      puts
-      puts json
+    options[:route] ||= ''
+    options[:query] ||= {}
+    options[:body] ||= {}
+
+    access_token = @@retrieve.call
+    self.check_expired(access_token)
+    options[:query][:access_token] = access_token['access_token']
+
+    begin
+      res = RestClient.post("#{@@api}#{options[:route]}?#{self.hash_to_query(options[:query])}",
+        options[:body].to_json,
+        :content_type => :json,
+        :accept => :json
+      )
+      return JSON.parse(res.body)
+    rescue => e
+      raise PlaylyfeError.new(e.response)
     end
-    return json
+  end
+
+  def self.patch(options = {})
+    options[:route] ||= ''
+    options[:query] ||= {}
+    options[:body] ||= {}
+
+    access_token = @@retrieve.call
+    self.check_expired(access_token)
+    options[:query][:access_token] = access_token['access_token']
+
+    begin
+      res = RestClient.patch("#{@@api}#{options[:route]}?#{self.hash_to_query(options[:query])}",
+        options[:body].to_json,
+        :content_type => :json,
+        :accept => :json
+      )
+      return JSON.parse(res.body)
+    rescue => e
+      raise PlaylyfeError.new(e.response)
+    end
+  end
+
+  def self.delete(options = {})
+    options[:route] ||= ''
+    options[:query] ||= {}
+
+    access_token = @@retrieve.call
+    self.check_expired(access_token)
+    options[:query][:access_token] = access_token['access_token']
+
+    begin
+      res = RestClient.delete("#{@@api}#{options[:route]}",
+        {:params => options[:query] }
+      )
+      JSON.parse(res.body)
+    rescue => e
+      raise PlaylyfeError.new(e.response)
+    end
+  end
+
+  def self.hash_to_query(hash)
+    return URI.encode(hash.map{|k,v| "#{k}=#{v}"}.join("&"))
   end
 end

data/test/test.rb

@@ -1,31 +1,137 @@
 require 'test/unit'
+require 'redis'
 require 'playlyfe'
 
 class PlaylyfeTest < Test::Unit::TestCase
 
-  def test_start
+  def test_invalid_client
+    begin
+      Playlyfe.init(
+        client_id: "wrong_id",
+        client_secret: "wrong_secret",
+        type: 'client'
+      )
+    rescue PlaylyfeError => e
+      assert_equal e.name,'client_auth_fail'
+      assert_equal e.message, 'Client authentication failed'
+    end
+  end
+
+  def test_wrong_init
+    begin
+      Playlyfe.init(
+        client_id: "Zjc0MWU0N2MtODkzNS00ZWNmLWEwNmYtY2M1MGMxNGQ1YmQ4",
+        client_secret: "YzllYTE5NDQtNDMwMC00YTdkLWFiM2MtNTg0Y2ZkOThjYTZkMGIyNWVlNDAtNGJiMC0xMWU0LWI2NGEtYjlmMmFkYTdjOTI3"
+      )
+    rescue PlaylyfeError => e
+      assert_equal e.name, 'init_failed'
+    end
+  end
+
+  def test_wrong_api
+    begin
+      Playlyfe.init(
+        client_id: "Zjc0MWU0N2MtODkzNS00ZWNmLWEwNmYtY2M1MGMxNGQ1YmQ4",
+        client_secret: "YzllYTE5NDQtNDMwMC00YTdkLWFiM2MtNTg0Y2ZkOThjYTZkMGIyNWVlNDAtNGJiMC0xMWU0LWI2NGEtYjlmMmFkYTdjOTI3",
+        type: 'client'
+      )
+      Playlyfe.get(route: '/gege', query: { player_id: 'student1' })
+    rescue PlaylyfeError => e
+      assert_equal e.name,'route_not_found'
+      assert_equal e.message, 'This route does not exist'
+    end
+  end
+
+  def test_init_staging
     Playlyfe.init(
-      client_id: "NjZlZWFiMWEtN2ZiOC00YmVmLTk2YWMtNDEyYTNmMjQ5NDBl",
-      client_secret: "NGRhMWJlYzUtODJiNS00ZTdkLTgzNTctMTQyMGEzNTljN2MwMTU2MGM3NTAtZjZiZS0xMWUzLTgxZjYtNmZhMGYyMzRkZGU3"
+      client_id: "Zjc0MWU0N2MtODkzNS00ZWNmLWEwNmYtY2M1MGMxNGQ1YmQ4",
+      client_secret: "YzllYTE5NDQtNDMwMC00YTdkLWFiM2MtNTg0Y2ZkOThjYTZkMGIyNWVlNDAtNGJiMC0xMWU0LWI2NGEtYjlmMmFkYTdjOTI3",
+      type: 'client'
     )
-    puts Playlyfe.token.to_hash
-
-    players = Playlyfe.get(url: '/players')
+    players = Playlyfe.get(route: '/players', query: { player_id: 'student1', limit: 1 })
     assert_not_nil players["data"]
     assert_not_nil players["data"][0]
 
+    begin
+      assert_nil Playlyfe.get(route: '/player')
+    rescue PlaylyfeError => e
+      assert_equal e.message, "The 'player_id' parameter should be specified in the query"
+    end
+
     player_id = 'student1'
-    player = Playlyfe.get(url: '/player', player: player_id)
+    player = Playlyfe.get(route: '/player', query: { player_id: player_id } )
     assert_equal player["id"], "student1"
     assert_equal player["alias"], "Student1"
     assert_equal player["enabled"], true
 
-    no_player = Playlyfe.get(url: '/player')
-    assert_nil no_player
+    Playlyfe.get(route: '/definitions/processes', query: { player_id: player_id } )
+    Playlyfe.get(route:'/definitions/teams', query: { player_id: player_id } )
+    Playlyfe.get(route: '/processes', query: { player_id: player_id } )
+    Playlyfe.get(route: '/teams', query: { player_id: player_id } )
+
+    processes = Playlyfe.get(route: '/processes', query: { player_id: 'student1', limit: 1, skip: 4 })
+    assert_equal processes["data"][0]["definition"], "module1"
+    assert_equal processes["data"].size, 1
+
+    new_process = Playlyfe.post(route: '/definitions/processes/module1', query: { player_id: player_id })
+    assert_equal new_process["definition"], "module1"
+    assert_equal new_process["state"], "ACTIVE"
+
+    patched_process = Playlyfe.patch(
+      route: "/processes/#{new_process['id']}",
+      query: { player_id: player_id },
+      body: { name: 'patched_process', access: 'PUBLIC' }
+    )
+
+    assert_equal patched_process['name'], 'patched_process'
+    assert_equal patched_process['access'], 'PUBLIC'
+
+    deleted_process = Playlyfe.delete(route: "/processes/#{new_process['id']}", query: { player_id: player_id })
+    assert_not_nil deleted_process['message']
+  end
 
-    Playlyfe.get(url: "/definitions/processes", player: player_id)
-    Playlyfe.get(url: "/definitions/teams", player: player_id)
-    Playlyfe.get(url: "/processes", player: player_id)
-    Playlyfe.get(url: "/teams", player: player_id)
+  def test_init_production
+    Playlyfe.init(
+      client_id: "N2Y4NjNlYTItODQzZi00YTQ0LTkzZWEtYTBiNTA2ODg3MDU4",
+      client_secret: "NDc3NTA0NmItMjBkZi00MjI2LWFhMjUtOTI0N2I1YTkxYjc2M2U3ZGI0MDAtNGQ1Mi0xMWU0LWJmZmUtMzkyZTdiOTYxYmMx",
+      type: 'client'
+    )
+    #player = Playlyfe.get(route: '/players', query: { player_id: 'l54328754bddc332e0021a847', limit: 1 })
+    #assert_equal player["data"][0]["email"], "peter@playlyfe.com"
+  end
+
+  def test_store
+    redis = Redis.new
+    Playlyfe.init(
+      client_id: "Zjc0MWU0N2MtODkzNS00ZWNmLWEwNmYtY2M1MGMxNGQ1YmQ4",
+      client_secret: "YzllYTE5NDQtNDMwMC00YTdkLWFiM2MtNTg0Y2ZkOThjYTZkMGIyNWVlNDAtNGJiMC0xMWU0LWI2NGEtYjlmMmFkYTdjOTI3",
+      type: 'client',
+      store: lambda { |token| redis.set('token', JSON.generate(token)) },
+      retrieve: lambda { return JSON.parse(redis.get('token')) }
+    )
+    players = Playlyfe.get(route: '/players', query: { player_id: 'student1', limit: 1 })
+    assert_not_nil players["data"]
+    assert_not_nil players["data"][0]
+  end
+
+  def test_auth_code_error
+    begin
+      Playlyfe.init(
+        client_id: "NGM2ZmYyNGQtNjViMy00YjQ0LWI0YTgtZTdmYWFlNDRkMmUx",
+        client_secret: "ZTQ0OWI4YTItYzE4ZC00MWQ5LTg3YjktMDI5ZjAxYTBkZmRiZGQ0NzI4OTAtNGQ1My0xMWU0LWJmZmUtMzkyZTdiOTYxYmMx",
+        type: 'code'
+      )
+    rescue PlaylyfeError => e
+      assert_equal e.name, 'init_failed'
+    end
+  end
+
+  def test_auth_code
+    Playlyfe.init(
+      client_id: "NGM2ZmYyNGQtNjViMy00YjQ0LWI0YTgtZTdmYWFlNDRkMmUx",
+      client_secret: "ZTQ0OWI4YTItYzE4ZC00MWQ5LTg3YjktMDI5ZjAxYTBkZmRiZGQ0NzI4OTAtNGQ1My0xMWU0LWJmZmUtMzkyZTdiOTYxYmMx",
+      type: 'code',
+      redirect_uri: 'https://playlyfe.com/v1/api'
+    )
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: playlyfe
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.4.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,16 +9,16 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-19 00:00:00.000000000 Z
+date: 2014-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: faraday
+  name: rest_client
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: 1.7.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,15 +26,15 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: 1.7.2
 - !ruby/object:Gem::Dependency
-  name: jwt
+  name: json
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 1.8.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -42,23 +42,39 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 1.8.1
 - !ruby/object:Gem::Dependency
-  name: json
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - '='
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.8.1
-  type: :runtime
+        version: '0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - '='
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.8.1
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: This gem can be used to interact with the playlyfe gamification platform
   using oauth 2.0
 email: peter@playlyfe.com
@@ -68,17 +84,9 @@ extra_rdoc_files: []
 files:
 - Rakefile
 - lib/playlyfe.rb
-- lib/access_token.rb
-- lib/base.rb
-- lib/client.rb
-- lib/client_credentials.rb
-- lib/error.rb
-- lib/response.rb
-- lib/strategy.rb
 - test/test.rb
 homepage: https://github.com/pyros2097/playlyfe-ruby-sdk
-licenses:
-- ApacheV2
+licenses: []
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -100,7 +108,7 @@ rubyforge_project:
 rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
-summary: The playlyfe ruby sdk
+summary: The Playlyfe Ruby SDK
 test_files:
 - test/test.rb
 has_rdoc: 

data/lib/access_token.rb

@@ -1,177 +0,0 @@
-module OAuth2
-  class AccessToken
-    attr_reader :client, :token, :expires_in, :expires_at, :params
-    attr_accessor :options, :refresh_token
-
-    def self.from_hash(client, hash)
-      new(client, hash.delete('access_token') || hash.delete(:access_token), hash)
-    end
-
-    class << self
-      # Initializes an AccessToken from a Hash
-      #
-      # @param [Client] the OAuth2::Client instance
-      # @param [Hash] a hash of AccessToken property values
-      # @return [AccessToken] the initalized AccessToken
-      def from_hash(client, hash)
-        new(client, hash.delete('access_token') || hash.delete(:access_token), hash)
-      end
-
-      # Initializes an AccessToken from a key/value application/x-www-form-urlencoded string
-      #
-      # @param [Client] client the OAuth2::Client instance
-      # @param [String] kvform the application/x-www-form-urlencoded string
-      # @return [AccessToken] the initalized AccessToken
-      def from_kvform(client, kvform)
-        from_hash(client, Rack::Utils.parse_query(kvform))
-      end
-    end
-
-    # Initalize an AccessToken
-    #
-    # @param [Client] client the OAuth2::Client instance
-    # @param [String] token the Access Token value
-    # @param [Hash] opts the options to create the Access Token with
-    # @option opts [String] :refresh_token (nil) the refresh_token value
-    # @option opts [FixNum, String] :expires_in (nil) the number of seconds in which the AccessToken will expire
-    # @option opts [FixNum, String] :expires_at (nil) the epoch time in seconds in which AccessToken will expire
-    # @option opts [Symbol] :mode (:header) the transmission mode of the Access Token parameter value
-    # one of :header, :body or :query
-    # @option opts [String] :header_format ('Bearer %s') the string format to use for the Authorization header
-    # @option opts [String] :param_name ('access_token') the parameter name to use for transmission of the
-    # Access Token value in :body or :query transmission mode
-    def initialize(client, token, opts = {})
-      @client = client
-      @token = token.to_s
-      [:refresh_token, :expires_in, :expires_at].each do |arg|
-        instance_variable_set("@#{arg}", opts.delete(arg) || opts.delete(arg.to_s))
-      end
-      @expires_in ||= opts.delete('expires')
-      @expires_in &&= @expires_in.to_i
-      @expires_at &&= @expires_at.to_i
-      @expires_at ||= Time.now.to_i + @expires_in if @expires_in
-      @options = {:mode => opts.delete(:mode) || :header,
-                  :header_format => opts.delete(:header_format) || 'Bearer %s',
-                  :param_name => opts.delete(:param_name) || 'access_token'}
-      @params = opts
-    end
-
-    # Indexer to additional params present in token response
-    #
-    # @param [String] key entry key to Hash
-    def [](key)
-      @params[key]
-    end
-
-    # Whether or not the token expires
-    #
-    # @return [Boolean]
-    def expires?
-      !!@expires_at # rubocop:disable DoubleNegation
-    end
-
-    # Whether or not the token is expired
-    #
-    # @return [Boolean]
-    def expired?
-      expires? && (expires_at < Time.now.to_i)
-    end
-
-    # Refreshes the current Access Token
-    #
-    # @return [AccessToken] a new AccessToken
-    # @note options should be carried over to the new AccessToken
-    def refresh!(params = {})
-      fail('A refresh_token is not available') unless refresh_token
-      params.merge!(:client_id => @client.id,
-                    :client_secret => @client.secret,
-                    :grant_type => 'refresh_token',
-                    :refresh_token => refresh_token)
-      new_token = @client.get_token(params)
-      new_token.options = options
-      new_token.refresh_token = refresh_token unless new_token.refresh_token
-      new_token
-    end
-
-    # Convert AccessToken to a hash which can be used to rebuild itself with AccessToken.from_hash
-    #
-    # @return [Hash] a hash of AccessToken property values
-    def to_hash
-      params.merge(:access_token => token, :refresh_token => refresh_token, :expires_at => expires_at)
-    end
-
-    # Make a request with the Access Token
-    #
-    # @param [Symbol] verb the HTTP request method
-    # @param [String] path the HTTP URL path of the request
-    # @param [Hash] opts the options to make the request with
-    # @see Client#request
-    def request(verb, path, opts = {}, &block)
-      self.token = opts
-      @client.request(verb, path, opts, &block)
-    end
-
-    # Make a GET request with the Access Token
-    #
-    # @see AccessToken#request
-    def get(path, opts = {}, &block)
-      request(:get, path, opts, &block)
-    end
-
-    # Make a POST request with the Access Token
-    #
-    # @see AccessToken#request
-    def post(path, opts = {}, &block)
-      request(:post, path, opts, &block)
-    end
-
-    # Make a PUT request with the Access Token
-    #
-    # @see AccessToken#request
-    def put(path, opts = {}, &block)
-      request(:put, path, opts, &block)
-    end
-
-    # Make a PATCH request with the Access Token
-    #
-    # @see AccessToken#request
-    def patch(path, opts = {}, &block)
-      request(:patch, path, opts, &block)
-    end
-
-    # Make a DELETE request with the Access Token
-    #
-    # @see AccessToken#request
-    def delete(path, opts = {}, &block)
-      request(:delete, path, opts, &block)
-    end
-
-    # Get the headers hash (includes Authorization token)
-    def headers
-      {'Authorization' => options[:header_format] % token}
-    end
-
-  private
-
-    def token=(opts) # rubocop:disable MethodLength
-      case options[:mode]
-      when :header
-        opts[:headers] ||= {}
-        opts[:headers].merge!(headers)
-      when :query
-        opts[:params] ||= {}
-        opts[:params][options[:param_name]] = token
-      when :body
-        opts[:body] ||= {}
-        if opts[:body].is_a?(Hash)
-          opts[:body][options[:param_name]] = token
-        else
-          opts[:body] << "&#{options[:param_name]}=#{token}"
-        end
-        # @todo support for multi-part (file uploads)
-      else
-        fail("invalid :mode option of #{options[:mode]}")
-      end
-    end
-  end
-end

data/lib/base.rb

@@ -1,16 +0,0 @@
-module OAuth2
-  module Strategy
-    class Base
-      def initialize(client)
-        @client = client
-      end
-
-      # The OAuth client_id and client_secret
-      #
-      # @return [Hash]
-      def client_params
-        {'client_id' => @client.id, 'client_secret' => @client.secret}
-      end
-    end
-  end
-end

data/lib/client.rb

@@ -1,155 +0,0 @@
-require 'faraday'
-require 'logger'
-require 'access_token'
-
-module OAuth2
-  # The OAuth2::Client class
-  class Client
-    attr_reader :id, :secret, :site
-    attr_accessor :options
-    attr_writer :connection
-
-    # Instantiate a new OAuth 2.0 client using the
-    # Client ID and Client Secret registered to your
-    # application.
-    #
-    # @param [String] client_id the client_id value
-    # @param [String] client_secret the client_secret value
-    # @param [Hash] opts the options to create the client with
-    # @option opts [String] :site the OAuth2 provider site host
-    # @option opts [String] :authorize_url ('/oauth/authorize') absolute or relative URL path to the Authorization endpoint
-    # @option opts [String] :token_url ('/oauth/token') absolute or relative URL path to the Token endpoint
-    # @option opts [Symbol] :token_method (:post) HTTP method to use to request token (:get or :post)
-    # @option opts [Hash] :connection_opts ({}) Hash of connection options to pass to initialize Faraday with
-    # @option opts [FixNum] :max_redirects (5) maximum number of redirects to follow
-    # @option opts [Boolean] :raise_errors (true) whether or not to raise an OAuth2::Error
-    # on responses with 400+ status codes
-    # @yield [builder] The Faraday connection builder
-    def initialize(client_id, client_secret, options = {}, &block)
-      opts = options.dup
-      @id = client_id
-      @secret = client_secret
-      @site = opts.delete(:site)
-      ssl = opts.delete(:ssl)
-      @options = {:authorize_url => '/oauth/authorize',
-                  :token_url => '/oauth/token',
-                  :token_method => :post,
-                  :connection_opts => {},
-                  :connection_build => block,
-                  :max_redirects => 5,
-                  :raise_errors => true}.merge(opts)
-      @options[:connection_opts][:ssl] = ssl if ssl
-    end
-
-    # Set the site host
-    #
-    # @param [String] the OAuth2 provider site host
-    def site=(value)
-      @connection = nil
-      @site = value
-    end
-
-    # The Faraday connection object
-    def connection
-      @connection ||= begin
-        conn = Faraday.new(site, options[:connection_opts])
-        conn.build do |b|
-          options[:connection_build].call(b)
-        end if options[:connection_build]
-        conn
-      end
-    end
-
-    # The authorize endpoint URL of the OAuth2 provider
-    #
-    # @param [Hash] params additional query parameters
-    def authorize_url(params = nil)
-      connection.build_url(options[:authorize_url], params).to_s
-    end
-
-    # The token endpoint URL of the OAuth2 provider
-    #
-    # @param [Hash] params additional query parameters
-    def token_url(params = nil)
-      connection.build_url(options[:token_url], params).to_s
-    end
-
-    # Makes a request relative to the specified site root.
-    #
-    # @param [Symbol] verb one of :get, :post, :put, :delete
-    # @param [String] url URL path of request
-    # @param [Hash] opts the options to make the request with
-    # @option opts [Hash] :params additional query parameters for the URL of the request
-    # @option opts [Hash, String] :body the body of the request
-    # @option opts [Hash] :headers http request headers
-    # @option opts [Boolean] :raise_errors whether or not to raise an OAuth2::Error on 400+ status
-    # code response for this request. Will default to client option
-    # @option opts [Symbol] :parse @see Response::initialize
-    # @yield [req] The Faraday request
-    def request(verb, url, opts = {}) # rubocop:disable CyclomaticComplexity, MethodLength
-      connection.response :logger, ::Logger.new($stdout) if ENV['OAUTH_DEBUG'] == 'true'
-
-      url = connection.build_url(url, opts[:params]).to_s
-
-      response = connection.run_request(verb, url, opts[:body], opts[:headers]) do |req|
-        yield(req) if block_given?
-      end
-      response = Response.new(response, :parse => opts[:parse])
-
-      case response.status
-      when 301, 302, 303, 307
-        opts[:redirect_count] ||= 0
-        opts[:redirect_count] += 1
-        return response if opts[:redirect_count] > options[:max_redirects]
-        if response.status == 303
-          verb = :get
-          opts.delete(:body)
-        end
-        request(verb, response.headers['location'], opts)
-      when 200..299, 300..399
-        # on non-redirecting 3xx statuses, just return the response
-        response
-      when 400..599
-        error = Error.new(response)
-        fail(error) if opts.fetch(:raise_errors, options[:raise_errors])
-        response.error = error
-        response
-      else
-        error = Error.new(response)
-        fail(error, "Unhandled status code value of #{response.status}")
-      end
-    end
-
-    # Initializes an AccessToken by making a request to the token endpoint
-    #
-    # @param [Hash] params a Hash of params for the token endpoint
-    # @param [Hash] access token options, to pass to the AccessToken object
-    # @param [Class] class of access token for easier subclassing OAuth2::AccessToken
-    # @return [AccessToken] the initalized AccessToken
-    def get_token(params, access_token_opts = {})
-      opts = {:raise_errors => options[:raise_errors], :parse => params.delete(:parse)}
-      if options[:token_method] == :post
-        headers = params.delete(:headers)
-        opts[:body] = params
-        opts[:headers] = {'Content-Type' => 'application/x-www-form-urlencoded'}
-        opts[:headers].merge!(headers) if headers
-      else
-        opts[:params] = params
-      end
-      response = request(options[:token_method], token_url, opts)
-      error = Error.new(response)
-      fail(error) if options[:raise_errors] && !(response.parsed.is_a?(Hash) && response.parsed['access_token'])
-      hash = response.parsed.merge(access_token_opts)
-      AccessToken.new(self, hash.delete('access_token') || hash.delete(:access_token), hash)
-      #AccessToken.from_hash(self, response.parsed.merge(access_token_opts))
-      #access_token_class.from_hash(self, response.parsed.merge(access_token_opts))
-    end
-
-    # The Client Credentials strategy
-    #
-    # @see http://tools.ietf.org/html/draft-ietf-oauth-v2-15#section-4.4
-    def client_credentials
-      @client_credentials ||= OAuth2::Strategy::ClientCredentials.new(self)
-    end
-  end
-end

data/lib/client_credentials.rb

@@ -1,37 +0,0 @@
-require 'base64'
-
-module OAuth2
-  module Strategy
-    # The Client Credentials Strategy
-    #
-    # @see http://tools.ietf.org/html/draft-ietf-oauth-v2-15#section-4.4
-    class ClientCredentials < Base
-      # Not used for this strategy
-      #
-      # @raise [NotImplementedError]
-      def authorize_url
-        fail(NotImplementedError, 'The authorization endpoint is not used in this strategy')
-      end
-
-      # Retrieve an access token given the specified client.
-      #
-      # @param [Hash] params additional params
-      # @param [Hash] opts options
-      def get_token(params = {}, opts = {})
-        request_body = opts.delete('auth_scheme') == 'request_body'
-        params.merge!('grant_type' => 'client_credentials')
-        params.merge!(request_body ? client_params : {:headers => {'Authorization' => authorization(client_params['client_id'], client_params['client_secret'])}})
-        @client.get_token(params, opts.merge('refresh_token' => nil))
-      end
-
-      # Returns the Authorization header value for Basic Authentication
-      #
-      # @param [String] The client ID
-      # @param [String] the client secret
-      def authorization(client_id, client_secret)
-        'Basic ' + Base64.encode64(client_id + ':' + client_secret).gsub("\n", '')
-      end
-    end
-  end
-end
-

data/lib/error.rb

@@ -1,24 +0,0 @@
-module OAuth2
-  class Error < StandardError
-    attr_reader :response, :code, :description
-
-    # standard error values include:
-    # :invalid_request, :invalid_client, :invalid_token, :invalid_grant, :unsupported_grant_type, :invalid_scope
-    def initialize(response)
-      response.error = self
-      @response = response
-
-      message = []
-
-      if response.parsed.is_a?(Hash)
-        @code = response.parsed['error']
-        @description = response.parsed['error_description']
-        message << "#{@code}: #{@description}"
-      end
-
-      message << response.body
-
-      super(message.join("\n"))
-    end
-  end
-end

data/lib/response.rb

@@ -1,81 +0,0 @@
-module OAuth2
-  # OAuth2::Response class
-  class Response
-    attr_reader :response
-    attr_accessor :error, :options
-
-    # Adds a new content type parser.
-    #
-    # @param [Symbol] key A descriptive symbol key such as :json or :query.
-    # @param [Array] One or more mime types to which this parser applies.
-    # @yield [String] A block returning parsed content.
-    def self.register_parser(key, mime_types, &block)
-      key = key.to_sym
-      PARSERS[key] = block
-      Array(mime_types).each do |mime_type|
-        CONTENT_TYPES[mime_type] = key
-      end
-    end
-
-    # Initializes a Response instance
-    #
-    # @param [Faraday::Response] response The Faraday response instance
-    # @param [Hash] opts options in which to initialize the instance
-    # @option opts [Symbol] :parse (:automatic) how to parse the response body. one of :query (for x-www-form-urlencoded),
-    # :json, or :automatic (determined by Content-Type response header)
-    def initialize(response, opts = {})
-      @response = response
-      @options = {:parse => :automatic}.merge(opts)
-    end
-
-    # The HTTP response headers
-    def headers
-      response.headers
-    end
-
-    # The HTTP response status code
-    def status
-      response.status
-    end
-
-    # The HTTP response body
-    def body
-      response.body || ''
-    end
-
-    # Procs that, when called, will parse a response body according
-    # to the specified format.
-    PARSERS = {
-      :json => lambda { |body| JSON.parse(body) rescue body }, # rubocop:disable RescueModifier
-      #:query => lambda { |body| Rack::Utils.parse_query(body) },
-      :text => lambda { |body| body }
-    }
-
-    # Content type assignments for various potential HTTP content types.
-    CONTENT_TYPES = {
-      'application/json' => :json,
-      'text/javascript' => :json,
-      'application/x-www-form-urlencoded' => :query,
-      'text/plain' => :text
-    }
-
-    # The parsed response body.
-    # Will attempt to parse application/x-www-form-urlencoded and
-    # application/json Content-Type response bodies
-    def parsed
-      return nil unless PARSERS.key?(parser)
-      @parsed ||= PARSERS[parser].call(body)
-    end
-
-    # Attempts to determine the content type of the response.
-    def content_type
-      ((response.headers.values_at('content-type', 'Content-Type').compact.first || '').split(';').first || '').strip
-    end
-
-    # Determines the parser that will be used to supply the content of #parsed
-    def parser
-      return options[:parse].to_sym if PARSERS.key?(options[:parse])
-      CONTENT_TYPES[content_type]
-    end
-  end
-end

data/lib/strategy.rb

@@ -1,73 +0,0 @@
-require 'jwt'
-
-module OAuth2
-  module Strategy
-    # The Client Assertion Strategy
-    #
-    # @see http://tools.ietf.org/html/draft-ietf-oauth-v2-10#section-4.1.3
-    #
-    # Sample usage:
-    # client = OAuth2::Client.new(client_id, client_secret,
-    # :site => 'http://localhost:8080')
-    #
-    # params = {:hmac_secret => "some secret",
-    # # or :private_key => "private key string",
-    # :iss => "http://localhost:3001",
-    # :prn => "me@here.com",
-    # :exp => Time.now.utc.to_i + 3600}
-    #
-    # access = client.assertion.get_token(params)
-    # access.token # actual access_token string
-    # access.get("/api/stuff") # making api calls with access token in header
-    #
-    class Assertion < Base
-      # Not used for this strategy
-      #
-      # @raise [NotImplementedError]
-      def authorize_url
-        fail(NotImplementedError, 'The authorization endpoint is not used in this strategy')
-      end
-
-      # Retrieve an access token given the specified client.
-      #
-      # @param [Hash] params assertion params
-      # pass either :hmac_secret or :private_key, but not both.
-      #
-      # params :hmac_secret, secret string.
-      # params :private_key, private key string.
-      #
-      # params :iss, issuer
-      # params :aud, audience, optional
-      # params :prn, principal, current user
-      # params :exp, expired at, in seconds, like Time.now.utc.to_i + 3600
-      #
-      # @param [Hash] opts options
-      def get_token(params = {}, opts = {})
-        hash = build_request(params)
-        @client.get_token(hash, opts.merge('refresh_token' => nil))
-      end
-
-      def build_request(params)
-        assertion = build_assertion(params)
-        {:grant_type => 'assertion',
-         :assertion_type => 'urn:ietf:params:oauth:grant-type:jwt-bearer',
-         :assertion => assertion,
-         :scope => params[:scope]
-        }.merge(client_params)
-      end
-
-      def build_assertion(params)
-        claims = {:iss => params[:iss],
-                  :aud => params[:aud],
-                  :prn => params[:prn],
-                  :exp => params[:exp]
-                 }
-        if params[:hmac_secret]
-          JWT.encode(claims, params[:hmac_secret], 'HS256')
-        elsif params[:private_key]
-          JWT.encode(claims, params[:private_key], 'RS256')
-        end
-      end
-    end
-  end
-end