doorkeeper-rethinkdb 1.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 856cb49c0238f249ed8a203b4dfb93bf57b1b2edf2953d47c8d0b1708a74063e
+  data.tar.gz: 8b5171dbe6d20e837f8a7b238079dd26b07808db5adc5192cab2439d597449e1
+SHA512:
+  metadata.gz: 5a1f0cc85cd8764b277cf4872e9284044305552a4f11f150f537489317689a0523864a917de070e5482f6d83179256c28e37026284a29ac8d6b4a9b76dd138aa
+  data.tar.gz: 26b37570029b3087f4a179c5ced78085fb4e952a30aed77830f9143f6a64526c06490d8b701be7b1575bbbce90c487d7a460e922a6b8d3899d7745d451a1343c

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 ACAProjects
+
+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 is furnished 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/README.md

@@ -0,0 +1,39 @@
+# doorkeeper-rethinkdb extension
+
+## Installation
+
+doorkeeper-rethinkdb provides doorkeeper support to rethinkdb
+To start using it, add to your Gemfile:
+
+``` ruby
+gem "doorkeeper-rethinkdb"
+```
+
+Run [doorkeeper’s installation generator]:
+
+    rails generate doorkeeper:install
+
+[doorkeeper’s installation generator]: https://github.com/doorkeeper-gem/doorkeeper#installation
+
+This will install the doorkeeper initializer into
+`config/initializers/doorkeeper.rb`.
+
+Set the ORM configuration:
+
+``` ruby
+Doorkeeper.configure do
+  orm :rethinkdb
+end
+```
+
+## Tests
+
+To run tests, clone this repository and run `rake`. It will copy and run
+doorkeeper’s original test suite, after configuring the ORM according to the
+variables defined in `.travis.yml` file.
+
+
+---
+
+Please refer to https://github.com/doorkeeper-gem/doorkeeper for instructions on
+doorkeeper’s project.

data/Rakefile

@@ -0,0 +1,23 @@
+require 'bundler/setup'
+require 'rspec/core/rake_task'
+
+task :load_doorkeeper do
+  `rm -rf spec/`
+  `git checkout -- spec`
+  `git submodule init`
+  `git submodule update`
+  `cp -r -n doorkeeper/spec .`
+  `bundle exec rspec`
+end
+
+desc 'Default: run specs.'
+task default: :spec
+
+desc 'Clone down doorkeeper specs'
+task spec: :load_doorkeeper
+
+RSpec::Core::RakeTask.new(:spec) do |config|
+  config.verbose = false
+end
+
+Bundler::GemHelper.install_tasks

data/lib/doorkeeper-rethinkdb.rb

@@ -0,0 +1,7 @@
+require 'doorkeeper-rethinkdb/version'
+
+require 'doorkeeper'
+require 'support/orm/rethinkdb'
+
+module DoorkeeperRethinkdb
+end

data/lib/doorkeeper-rethinkdb/version.rb

@@ -0,0 +1,3 @@
+module DoorkeeperRethinkdb
+    VERSION = "1.1.1"
+end

data/lib/support/orm/rethinkdb.rb

@@ -0,0 +1,20 @@
+module Doorkeeper
+  module Orm
+    module Rethinkdb
+      def self.initialize_models!
+        require 'support/orm/rethinkdb/timestamps'
+        require 'support/orm/rethinkdb/scopes'
+        require 'support/orm/rethinkdb/access_grant'
+        require 'support/orm/rethinkdb/access_token'
+        require 'support/orm/rethinkdb/application'
+      end
+
+      def self.initialize_application_owner!
+        #require 'doorkeeper/models/concerns/ownership'
+        #Doorkeeper::Application.send :include, Doorkeeper::Models::Ownership
+      end
+
+      def self.check_requirements!(_config); end
+    end
+  end
+end

data/lib/support/orm/rethinkdb/access_grant.rb

@@ -0,0 +1,122 @@
+
+module Doorkeeper
+  class AccessGrant
+    include NoBrainer::Document
+
+    table_config name: 'doorkeeper_grant'
+
+    include OAuth::Helpers
+    include Models::Expirable
+    include Models::Revocable
+    include Models::Accessible
+    include Models::Scopes
+    include Models::SecretStorable
+
+    include Timestamps
+
+    belongs_to  :application, class_name: 'Doorkeeper::Application'
+
+    field :resource_owner_id, type: String
+    field :token,             type: String, uniq: true, index: true
+    field :scopes,            type: String
+    field :redirect_uri,      type: String
+
+    field :expires_in,        type: Integer
+    field :ttl,               type: Integer
+    field :revoked_at,        type: Time
+
+    # PKCE support
+    field :code_challenge,        type: String
+    field :code_challenge_method, type: String
+
+    index :ttl
+
+    class << self
+      def by_token(token)
+        find_by_plaintext_token(:token, token)
+      end
+
+      def find_by_plaintext_token(attr, token)
+        # We are not implementing the fallback strategy
+        where(attr => secret_strategy.transform_secret(token.to_s)).first
+      end
+
+      # @param code_verifier [#to_s] a one time use value (any object that responds to `#to_s`)
+      #
+      # @return [#to_s] An encoded code challenge based on the provided verifier
+      # suitable for PKCE validation
+      #
+      def generate_code_challenge(code_verifier)
+        padded_result = Base64.urlsafe_encode64(Digest::SHA256.digest(code_verifier))
+        padded_result.split("=")[0] # Remove any trailing '='
+      end
+
+      def pkce_supported?
+        true
+      end
+
+      ##
+      # Determines the secret storing transformer
+      # Unless configured otherwise, uses the plain secret strategy
+      #
+      # @return [Doorkeeper::SecretStoring::Base]
+      #
+      def secret_strategy
+        ::Doorkeeper.config.token_secret_strategy
+      end
+
+      ##
+      # Determine the fallback storing strategy
+      # Unless configured, there will be no fallback
+      #
+      # @return [Doorkeeper::SecretStoring::Base]
+      #
+      def fallback_secret_strategy
+        ::Doorkeeper.config.token_secret_fallback_strategy
+      end
+    end
+
+    validates :resource_owner_id, :application, :token, :expires_in, :redirect_uri, presence: true
+    before_validation :generate_token, on: :create
+
+    def transaction; yield; end
+    def lock!; end
+
+    def uses_pkce?
+      self.code_challenge.present?
+    end
+
+    # We keep a volatile copy of the raw token for initial communication
+    # The stored refresh_token may be mapped and not available in cleartext.
+    #
+    # Some strategies allow restoring stored secrets (e.g. symmetric encryption)
+    # while hashing strategies do not, so you cannot rely on this value
+    # returning a present value for persisted tokens.
+    def plaintext_token
+      if secret_strategy.allows_restoring_secrets?
+        secret_strategy.restore_secret(self, :token)
+      else
+        @raw_token
+      end
+    end
+
+    def revoke(clock = Time)
+      self.revoked_at = clock.now.utc
+      self.save!
+    end
+
+    private
+
+    # Generates token value with UniqueToken class.
+    #
+    # @return [String] token value
+    #
+    def generate_token
+      self.ttl = (self.created_at + self.expires_in + 30).to_i if self.created_at && self.expires_in
+      if self.token.blank?
+        @raw_token = Doorkeeper::OAuth::Helpers::UniqueToken.generate
+        secret_strategy.store_secret(self, :token, @raw_token)
+      end
+    end
+  end
+end

data/lib/support/orm/rethinkdb/access_token.rb

@@ -0,0 +1,376 @@
+
+module Doorkeeper
+  class AccessToken
+    include NoBrainer::Document
+
+    table_config name: 'doorkeeper_token'
+
+    include OAuth::Helpers
+    include Models::Expirable
+    include Models::Reusable
+    include Models::Revocable
+    include Models::Accessible
+    include Models::Scopes
+    include Models::SecretStorable
+
+    include ::Doorkeeper::Rethinkdb::Timestamps
+
+    attr_writer :use_refresh_token
+
+    belongs_to  :application, class_name: 'Doorkeeper::Application'
+
+    field :resource_owner_id,       type: String, index: true
+    field :token,                   type: String, uniq: true, index: true
+    field :refresh_token,           type: String, index: true
+
+    field :scopes,                  type: String
+    field :previous_refresh_token,  type: String, default: ->{ '' }
+    field :expires_in,              type: Integer
+    field :ttl,                     type: Integer
+    field :revoked_at,              type: Time
+
+    index :ttl
+
+    alias :plaintext_token :token
+    alias :plaintext_refresh_token :refresh_token
+
+    validates :resource_owner_id, :application, :expires_in, :token, presence: true
+
+    class << self
+      def refresh_token_revoked_on_use?
+        true
+      end
+
+      def find_by_plaintext_token(attr, token)
+        # We are not implementing the fallback strategy
+        where(attr => secret_strategy.transform_secret(token.to_s)).first
+      end
+
+      # Returns an instance of the Doorkeeper::AccessToken with
+      # specific token value.
+      #
+      # @param token [#to_s]
+      #   token value (any object that responds to `#to_s`)
+      #
+      # @return [Doorkeeper::AccessToken, nil] AccessToken object or nil
+      #   if there is no record with such token
+      #
+      def by_token(token)
+        find_by_plaintext_token(:token, token)
+      end
+
+      # Returns an instance of the Doorkeeper::AccessToken
+      # with specific token value.
+      #
+      # @param refresh_token [#to_s]
+      #   refresh token value (any object that responds to `#to_s`)
+      #
+      # @return [Doorkeeper::AccessToken, nil] AccessToken object or nil
+      #   if there is no record with such refresh token
+      #
+      def by_refresh_token(refresh_token)
+        find_by_plaintext_token(:refresh_token, refresh_token)
+      end
+
+      # Returns an instance of the Doorkeeper::AccessToken
+      # found by previous refresh token. Keep in mind that value
+      # of the previous_refresh_token isn't encrypted using
+      # secrets strategy.
+      #
+      # @param previous_refresh_token [#to_s]
+      #   previous refresh token value (any object that responds to `#to_s`)
+      #
+      # @return [Doorkeeper::AccessToken, nil] AccessToken object or nil
+      #   if there is no record with such refresh token
+      #
+      def by_previous_refresh_token(previous_refresh_token)
+        return nil unless previous_refresh_token.present?
+        where(previous_refresh_token: previous_refresh_token).first
+      end
+
+      # Revokes AccessToken records that have not been revoked and associated
+      # with the specific Application and Resource Owner.
+      #
+      # @param application_id [Integer]
+      #   ID of the Application
+      # @param resource_owner [ActiveRecord::Base]
+      #   instance of the Resource Owner model
+      #
+      def revoke_all_for(application_id, resource_owner)
+        where(application_id: application_id, resource_owner_id: resource_owner.id).each do |at|
+          at.revoke
+        end
+      end
+
+      # Looking for not revoked Access Token record that belongs to specific
+      # Application and Resource Owner.
+      #
+      # @param application_id [Integer]
+      #   ID of the Application model instance
+      # @param resource_owner_id [Integer]
+      #   ID of the Resource Owner model instance
+      #
+      # @return [Doorkeeper::AccessToken, nil] matching AccessToken object or
+      #   nil if nothing was found
+      #
+      def last_authorized_token_for(application_id, resource_owner_id)
+        resource_owner_id = resource_owner_id.try(:id) || resource_owner_id
+        result = where(application_id: application_id, resource_owner_id: resource_owner_id).last
+        return nil unless result
+        result[:revoked_at] ? nil : result
+      end
+
+      # Looking for not expired Access Token with a matching set of scopes
+      # that belongs to specific Application and Resource Owner.
+      #
+      # @param application [Doorkeeper::Application]
+      #   Application instance
+      # @param resource_owner_or_id [ActiveRecord::Base, Integer]
+      #   Resource Owner model instance or it's ID
+      # @param scopes [String, Doorkeeper::OAuth::Scopes]
+      #   set of scopes
+      #
+      # @return [Doorkeeper::AccessToken, nil] Access Token instance or
+      #   nil if matching record was not found
+      #
+      def matching_token_for(application, resource_owner_or_id, scopes)
+        resource_owner_id = resource_owner_or_id.try(:id) || resource_owner_or_id
+        token = last_authorized_token_for(application.try(:id), resource_owner_id)
+        if token && scopes_match?(token.scopes, scopes, application.try(:scopes))
+          token
+        end
+      end
+
+      # Checks whether the token scopes match the scopes from the parameters or
+      # Application scopes (if present).
+      #
+      # @param token_scopes [#to_s]
+      #   set of scopes (any object that responds to `#to_s`)
+      # @param param_scopes [String]
+      #   scopes from params
+      # @param app_scopes [String]
+      #   Application scopes
+      #
+      # @return [Boolean] true if all scopes and blank or matches
+      #   and false in other cases
+      #
+      def scopes_match?(token_scopes, param_scopes, app_scopes)
+        (!token_scopes.present? && !param_scopes.present?) ||
+          Doorkeeper::OAuth::Helpers::ScopeChecker.match?(
+            token_scopes.to_s,
+            param_scopes,
+            app_scopes
+          )
+      end
+
+      # Looking for not expired AccessToken record with a matching set of
+      # scopes that belongs to specific Application and Resource Owner.
+      # If it doesn't exists - then creates it.
+      #
+      # @param application [Doorkeeper::Application]
+      #   Application instance
+      # @param resource_owner_id [ActiveRecord::Base, Integer]
+      #   Resource Owner model instance or it's ID
+      # @param scopes [#to_s]
+      #   set of scopes (any object that responds to `#to_s`)
+      # @param expires_in [Integer]
+      #   token lifetime in seconds
+      # @param use_refresh_token [Boolean]
+      #   whether to use the refresh token
+      #
+      # @return [Doorkeeper::AccessToken] existing record or a new one
+      #
+      def find_or_create_for(application:, resource_owner:, scopes:, **token_attributes)
+        resource_owner = resource_owner.try(:id) || resource_owner
+
+        if Doorkeeper.config.reuse_access_token
+          access_token = matching_token_for(application, resource_owner, scopes)
+
+          return access_token if access_token&.reusable?
+        end
+
+        create!(
+          application_id:    application.try(:id),
+          resource_owner_id: resource_owner || application.try(:owner_id),
+          scopes:            scopes.to_s,
+          **token_attributes,
+        )
+      end
+
+      def create_for(application:, resource_owner:, scopes:, **token_attributes)
+        token_attributes[:application_id] = application&.id
+        token_attributes[:scopes] = scopes.to_s
+
+        resource_owner = resource_owner.try(:id) || resource_owner
+        token_attributes[:resource_owner_id] = resource_owner || application.try(:owner_id)
+
+        create!(**token_attributes)
+      end
+
+      ##
+      # Determines the secret storing transformer
+      # Unless configured otherwise, uses the plain secret strategy
+      #
+      # @return [Doorkeeper::SecretStoring::Base]
+      #
+      def secret_strategy
+        ::Doorkeeper.config.token_secret_strategy
+      end
+
+      ##
+      # Determine the fallback storing strategy
+      # Unless configured, there will be no fallback
+      def fallback_secret_strategy
+        ::Doorkeeper.config.token_secret_fallback_strategy
+      end
+    end
+
+    # Access Token type: Bearer.
+    # @see https://tools.ietf.org/html/rfc6750
+    #   The OAuth 2.0 Authorization Framework: Bearer Token Usage
+    #
+    def token_type
+      'bearer'
+    end
+
+    def use_refresh_token?
+      @use_refresh_token ||= false
+      !!@use_refresh_token
+    end
+
+    # JSON representation of the Access Token instance.
+    #
+    # @return [Hash] hash with token data
+    def as_json(_options = {})
+      {
+        resource_owner_id:  resource_owner_id,
+        scopes:             scopes,
+        expires_in_seconds: expires_in_seconds,
+        application:        { uid: application.try(:uid) },
+        created_at:         created_at.to_i
+      }
+    end
+
+    # Indicates whether the token instance have the same credential
+    # as the other Access Token.
+    #
+    # @param access_token [Doorkeeper::AccessToken] other token
+    #
+    # @return [Boolean] true if credentials are same of false in other cases
+    #
+    def same_credential?(access_token)
+      application_id == access_token.application_id &&
+      resource_owner_id == access_token.resource_owner_id
+    end
+
+    # Indicates if token is acceptable for specific scopes.
+    #
+    # @param scopes [Array<String>] scopes
+    #
+    # @return [Boolean] true if record is accessible and includes scopes or
+    #   false in other cases
+    #
+    def acceptable?(scopes)
+      accessible? && includes_scope?(*scopes)
+    end
+
+    # We keep a volatile copy of the raw refresh token for initial communication
+    # The stored refresh_token may be mapped and not available in cleartext.
+    def plaintext_refresh_token
+      if secret_strategy.allows_restoring_secrets?
+        secret_strategy.restore_secret(self, :refresh_token)
+      else
+        @raw_refresh_token
+      end
+    end
+
+    # We keep a volatile copy of the raw token for initial communication
+    # The stored refresh_token may be mapped and not available in cleartext.
+    #
+    # Some strategies allow restoring stored secrets (e.g. symmetric encryption)
+    # while hashing strategies do not, so you cannot rely on this value
+    # returning a present value for persisted tokens.
+    def plaintext_token
+      if secret_strategy.allows_restoring_secrets?
+        secret_strategy.restore_secret(self, :token)
+      else
+        @raw_token
+      end
+    end
+
+    # Revokes token with `:refresh_token` equal to `:previous_refresh_token`
+    # and clears `:previous_refresh_token` attribute.
+    #
+    def revoke_previous_refresh_token!
+      return unless self.class.refresh_token_revoked_on_use?
+      self.previous_refresh_token = ''
+      self.save!
+    end
+
+    def revoke(clock = Time)
+      self.revoked_at = clock.now.utc
+      self.save!
+    end
+
+    def transaction; yield; end
+    def lock!; end
+
+    private
+
+    before_validation :generate_token, on: :create
+    before_validation :generate_refresh_token, on: :create, if: :use_refresh_token?
+
+    validate :refresh_token_unique
+
+    def refresh_token_unique
+      if refresh_token_changed? && refresh_token.present? && ::Doorkeeper::AccessToken.where(refresh_token: refresh_token).count > 0
+        errors.add(:refresh_token, "must be unique")
+      end
+    end
+
+    # Generates refresh token with UniqueToken generator.
+    #
+    # @return [String] refresh token value
+    #
+    def generate_refresh_token
+      if self.refresh_token.blank?
+        @raw_refresh_token = UniqueToken.generate
+        secret_strategy.store_secret(self, :refresh_token, @raw_refresh_token)
+      end
+    end
+
+    def generate_token
+      return if self.token.present?
+
+      self.created_at ||= Time.now.utc
+
+      if use_refresh_token?
+        self.ttl = (self.created_at + 1.months).to_i
+      else
+        self.ttl = (self.created_at + self.expires_in + 30).to_i
+      end
+
+      generator = Doorkeeper.configuration.access_token_generator.constantize
+      @raw_token = generator.generate(
+        resource_owner_id: resource_owner_id,
+        scopes: scopes,
+        application: application,
+        expires_in: expires_in,
+        created_at: created_at
+      )
+      secret_strategy.store_secret(self, :token, @raw_token)
+      @raw_token
+    rescue NoMethodError
+      raise Errors::UnableToGenerateToken, "#{generator} does not respond to `.generate`."
+    rescue NameError
+      raise Errors::TokenGeneratorNotFound, "#{generator} not found"
+    end
+  end
+
+  # # Skips validation if field is empty
+  # class UniqueOrEmptyValidator < UniquenessValidator
+  #   def validate_each(doc, attr, value)
+  #     super if value
+  #   end
+  # end
+end

data/lib/support/orm/rethinkdb/application.rb

@@ -0,0 +1,93 @@
+
+# Load these before the has_many
+require File.expand_path("../access_grant", __FILE__)
+require File.expand_path("../access_token", __FILE__)
+
+# Required for Rails 6 support
+require "doorkeeper/orm/active_record/redirect_uri_validator"
+
+module Doorkeeper
+  class Application
+    include NoBrainer::Document
+
+    table_config name: 'doorkeeper_app'
+
+    include OAuth::Helpers
+    include Models::Scopes
+
+    field :name, type: String
+    field :uid, type: String, uniq: true, index: true
+    field :secret, type: String
+    field :scopes, type: String
+    field :redirect_uri, type: String, uniq: true, index: true
+
+    field :skip_authorization, type: Boolean, default: false
+    field :confidential, type: Boolean, default: false
+
+    field :owner_id, type: String
+
+    validates :owner, presence: true, if: :validate_owner?
+    def validate_owner?
+      Doorkeeper.configuration.confirm_application_owner?
+    end
+
+    has_many :access_grants, dependent: :destroy, class_name: 'Doorkeeper::AccessGrant'
+    has_many :access_tokens, dependent: :destroy, class_name: 'Doorkeeper::AccessToken'
+
+    class << self
+      def by_uid(uid)
+        where(uid: uid).first
+      end
+
+      def by_uid_and_secret(uid, secret)
+        where(uid: uid, secret: secret).first
+      end
+
+      def by_uid_and_secret(uid, secret)
+        app = by_uid(uid)
+        return unless app
+        return app if secret.blank? && !app.confidential?
+        return unless app.secret_matches?(secret)
+
+        app
+      end
+
+      def authorized_for(resource_owner)
+        AccessToken.find_by_resource_owner_id(resource_owner.id).collect(&:application)
+      end
+    end
+
+    def authorized_for_resource_owner?(resource_owner)
+      Doorkeeper.configuration.authorize_resource_owner_for_client.call(self, resource_owner)
+    end
+
+    def secret_matches?(input)
+      # return false if either is nil, since secure_compare depends on strings
+      # but Application secrets MAY be nil depending on confidentiality.
+      return false if input.nil? || secret.nil?
+
+      # When matching the secret by comparer function, all is well.
+      input == secret
+    end
+
+    private
+
+    validates :name, :secret, :uid, presence: true
+    validates :redirect_uri, "doorkeeper/redirect_uri": true
+    validates :confidential, inclusion: { in: [true, false] }
+
+    before_validation :generate_uid, :generate_secret, on: :create
+
+    def has_scopes?
+      true
+    end
+
+    def generate_uid
+      self.uid = UniqueToken.generate if uid.blank?
+    end
+
+    def generate_secret
+      self.secret = UniqueToken.generate if secret.blank?
+    end
+  end
+end

data/lib/support/orm/rethinkdb/scopes.rb

@@ -0,0 +1,22 @@
+
+module Doorkeeper
+  # Reopen to align with NoBrainer's exclusively `super` overrides.
+  # ORM is thrust into an infinite loop, otherwise.
+  module Models::Scopes
+    def scopes
+      OAuth::Scopes.from_string(super)
+    end
+
+    def scopes=(value)
+      super Array(value).join(" ")
+    end
+
+    def scopes_string
+      self._read_attribute(:scopes)
+    end
+
+    def includes_scope?(*required_scopes)
+      required_scopes.blank? || required_scopes.any? { |scope| scopes.exists?(scope.to_s) }
+    end
+  end
+end

data/lib/support/orm/rethinkdb/timestamps.rb

@@ -0,0 +1,32 @@
+require 'date'
+
+module Doorkeeper
+  module Rethinkdb
+    module Timestamps
+      extend ActiveSupport::Concern
+
+      included do
+        field :revoked_at, type: Integer
+        field :created_at, type: Integer, default: ->{ Time.now.to_i + 1 }
+      end
+
+      def revoked_at
+        revoked = super
+        Time.at(revoked) unless revoked.nil?
+      end
+
+      def revoked_at=(time)
+        if time
+          number = time.is_a?(Numeric) ? time.to_i : time.to_time.to_i
+          super number
+        else
+          super nil
+        end
+      end
+
+      def created_at
+        Time.at(super)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,207 @@
+--- !ruby/object:Gem::Specification
+name: doorkeeper-rethinkdb
+version: !ruby/object:Gem::Version
+  version: 1.1.1
+platform: ruby
+authors:
+- Stephen von Takach
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-08-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: doorkeeper
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
+- !ruby/object:Gem::Dependency
+  name: nobrainer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.33.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.33.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: capybara
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: factory_girl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.7'
+- !ruby/object:Gem::Dependency
+  name: generator_spec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 12.3.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 12.3.3
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+description: Doorkeeper RethinkDB ORMs
+email:
+- steve@aca.im
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/doorkeeper-rethinkdb.rb
+- lib/doorkeeper-rethinkdb/version.rb
+- lib/support/orm/rethinkdb.rb
+- lib/support/orm/rethinkdb/access_grant.rb
+- lib/support/orm/rethinkdb/access_token.rb
+- lib/support/orm/rethinkdb/application.rb
+- lib/support/orm/rethinkdb/scopes.rb
+- lib/support/orm/rethinkdb/timestamps.rb
+homepage: http://github.com/aca-labs/doorkeeper-rethinkdb
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.7.7
+signing_key:
+specification_version: 4
+summary: Doorkeeper RethinkDB ORMs
+test_files: []