doorkeeper-sequel 1.4.0 → 1.5.0

data/lib/doorkeeper/orm/sequel/models/access_token_mixin.rb

@@ -1,168 +0,0 @@
-module Doorkeeper
-  module Orm
-    module Sequel
-      module AccessTokenMixin
-        extend ActiveSupport::Concern
-
-        include SequelCompat
-        include OAuth::Helpers
-        include Models::Expirable
-        include Models::Revocable
-        include Models::Accessible
-        include Models::Scopes
-
-        included do
-          plugin :validation_helpers
-          plugin :timestamps
-
-          many_to_one :application, class: 'Doorkeeper::Application'
-
-          attr_writer :use_refresh_token
-
-          set_allowed_columns :application_id, :resource_owner_id, :expires_in,
-                              :scopes, :use_refresh_token, :previous_refresh_token
-
-          def before_validation
-            if new?
-              generate_token
-              generate_refresh_token if use_refresh_token?
-            end
-
-            super
-          end
-
-          def validate
-            super
-            validates_presence [:token]
-            validates_unique [:token]
-
-            validates_unique [:refresh_token] if use_refresh_token?
-          end
-
-          def application_id?
-            application_id.present?
-          end
-        end
-
-        module ClassMethods
-          def by_token(token)
-            first(token: token.to_s)
-          end
-
-          def by_refresh_token(refresh_token)
-            first(refresh_token: refresh_token.to_s)
-          end
-
-          def revoke_all_for(application_id, resource_owner, clock = Time)
-            where(application_id: application_id,
-                  resource_owner_id: resource_owner.id,
-                  revoked_at: nil)
-              .update(revoked_at: clock.now.utc)
-          end
-
-          def matching_token_for(application, resource_owner_or_id, scopes)
-            resource_owner_id = if resource_owner_or_id.respond_to?(:to_key)
-                                  resource_owner_or_id.id
-                                else
-                                  resource_owner_or_id
-                                end
-            token = last_authorized_token_for(application.try(:id), resource_owner_id)
-            if token && scopes_match?(token.scopes, scopes, application.try(:scopes))
-              token
-            end
-          end
-
-          def scopes_match?(token_scopes, param_scopes, app_scopes)
-            (token_scopes.blank? && param_scopes.blank?) ||
-              Doorkeeper::OAuth::Helpers::ScopeChecker.match?(
-                token_scopes.to_s,
-                param_scopes,
-                app_scopes
-              )
-          end
-
-          def find_or_create_for(application, resource_owner_id, scopes, expires_in, use_refresh_token)
-            if Doorkeeper.configuration.reuse_access_token
-              access_token = matching_token_for(application, resource_owner_id, scopes)
-              return access_token if access_token && !access_token.expired?
-            end
-
-            create!(
-              application_id: application.try(:id),
-              resource_owner_id: resource_owner_id,
-              scopes: scopes.to_s,
-              expires_in: expires_in,
-              use_refresh_token: use_refresh_token
-            )
-          end
-
-          def last_authorized_token_for(application_id, resource_owner_id)
-            where(application_id: application_id,
-                  resource_owner_id: resource_owner_id,
-                  revoked_at: nil)
-              .send(order_method, created_at_desc)
-              .first
-          end
-        end
-
-        def token_type
-          'bearer'
-        end
-
-        def use_refresh_token?
-          !!@use_refresh_token
-        end
-
-        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
-
-        # It indicates whether the tokens have the same credential
-        def same_credential?(access_token)
-          application_id == access_token.application_id &&
-            resource_owner_id == access_token.resource_owner_id
-        end
-
-        def acceptable?(scopes)
-          accessible? && includes_scope?(*scopes)
-        end
-
-        private
-
-        def generate_refresh_token
-          self[:refresh_token] = UniqueToken.generate
-        end
-
-        def generate_token
-          self[:created_at] ||= Time.now.utc
-
-          generator = token_generator
-          unless generator.respond_to?(:generate)
-            raise Errors::UnableToGenerateToken, "#{generator} does not respond to `.generate`."
-          end
-
-          self[:token] = generator.generate(
-            resource_owner_id: resource_owner_id,
-            scopes: scopes,
-            application: application,
-            expires_in: expires_in,
-            created_at: created_at
-          )
-        end
-
-        def token_generator
-          generator_name = Doorkeeper.configuration.access_token_generator
-          generator_name.constantize
-        rescue NameError
-          raise Errors::TokenGeneratorNotFound, "#{generator_name} not found"
-        end
-      end
-    end
-  end
-end

data/lib/doorkeeper/orm/sequel/models/application_mixin.rb

@@ -1,70 +0,0 @@
-require_relative '../validators/redirect_uri_validator'
-
-module Doorkeeper
-  module Orm
-    module Sequel
-      module ApplicationMixin
-        extend ActiveSupport::Concern
-
-        include SequelCompat
-        include OAuth::Helpers
-        include Models::Scopes
-        include Doorkeeper::Orm::Sequel::RedirectUriValidator
-
-        included do
-          plugin :validation_helpers
-          plugin :timestamps
-          plugin :association_dependencies
-
-          one_to_many :access_grants, class: 'Doorkeeper::AccessGrant'
-          one_to_many :access_tokens, class: 'Doorkeeper::AccessToken'
-
-          add_association_dependencies access_grants: :delete, access_tokens: :delete
-
-          set_allowed_columns :name, :redirect_uri, :scopes
-
-          def before_validation
-            generate_uid
-            generate_secret
-            super
-          end
-
-          def validate
-            super
-            validates_presence [:name, :secret, :uid]
-            validates_unique [:uid]
-            validates_redirect_uri :redirect_uri
-
-            if respond_to?(:validate_owner?)
-              validates_presence [:owner_id] if validate_owner?
-            end
-          end
-        end
-
-        module ClassMethods
-          def by_uid_and_secret(uid, secret)
-            first(uid: uid.to_s, secret: secret.to_s)
-          end
-
-          def by_uid(uid)
-            first(uid: uid.to_s)
-          end
-        end
-
-        private
-
-        def has_scopes?
-          Doorkeeper::Application.columns.include?('scopes')
-        end
-
-        def generate_uid
-          self.uid = UniqueToken.generate if uid.blank? && new?
-        end
-
-        def generate_secret
-          self.secret = UniqueToken.generate if secret.blank? && new?
-        end
-      end
-    end
-  end
-end

data/lib/doorkeeper/orm/sequel/models/concerns/ownership.rb

@@ -1,19 +0,0 @@
-module Doorkeeper
-  module Orm
-    module Sequel
-      module Ownership
-        extend ActiveSupport::Concern
-
-        included do
-          plugin :polymorphic
-
-          many_to_one :owner, polymorphic: true
-
-          def validate_owner?
-            Doorkeeper.configuration.confirm_application_owner?
-          end
-        end
-      end
-    end
-  end
-end

data/lib/doorkeeper/orm/sequel/models/concerns/sequel_compat.rb

@@ -1,59 +0,0 @@
-module Doorkeeper
-  module Orm
-    module Sequel
-      module SequelCompat
-        extend ActiveSupport::Concern
-
-        # ActiveRecord methods used by Doorkeeper outside the ORM.
-        # Should be extracted at the architectural level.
-        included do
-          plugin :active_model
-
-          # Sequel 4.47 and higher deprecated #set_allowed_columns
-          if (::Sequel::MAJOR >= 4 && ::Sequel::MINOR >= 47) || ::Sequel::MAJOR >= 5
-            plugin :whitelist_security
-          end
-
-          self.raise_on_save_failure = false
-
-          def update_attribute(column, value)
-            self[column] = value
-            save(columns: [column.to_sym], validate: false)
-          end
-
-          def update_attributes(*args)
-            update(*args)
-          end
-
-          def save!(*)
-            save(raise_on_failure: true)
-          end
-
-          def transaction(opts = {}, &block)
-            db.transaction(opts, &block)
-          end
-        end
-
-        module ClassMethods
-          def create!(values = {}, &block)
-            new(values, &block).save(raise_on_failure: true)
-          end
-
-          def table_exists?
-            db.table_exists?(table_name)
-          end
-
-          # find(1) or find("1") - will work like find(id: 1)
-          # find(name: 'John') - will work like find(name: 'John')
-          def find(*args, &block)
-            if args.first.is_a?(Hash)
-              super(*args, &block)
-            else
-              super(id: args)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/doorkeeper/orm/sequel/validators/redirect_uri_validator.rb

@@ -1,57 +0,0 @@
-module Doorkeeper
-  module Orm
-    module Sequel
-      module RedirectUriValidator
-        extend ActiveSupport::Concern
-
-        included do
-          def validates_redirect_uri(attribute)
-            value = self[attribute]
-
-            if value.blank?
-              add_error(attribute, :blank)
-            else
-              value.split.each do |val|
-                uri = ::URI.parse(val)
-                return true if native_redirect_uri?(uri)
-                validate_uri(uri, attribute)
-              end
-            end
-          rescue URI::InvalidURIError
-            add_error(attribute, :invalid_uri)
-          end
-
-          private
-
-          def native_redirect_uri?(uri)
-            native_redirect_uri.present? && uri.to_s == native_redirect_uri.to_s
-          end
-
-          def validate_uri(uri, attribute)
-            {
-              fragment_present: uri.fragment.present?,
-              relative_uri: uri.scheme.nil? || uri.host.nil?,
-              secured_uri: invalid_ssl_uri?(uri)
-            }.each do |error, condition|
-              add_error(attribute, error) if condition
-            end
-          end
-
-          def invalid_ssl_uri?(uri)
-            forces_ssl = Doorkeeper.configuration.force_ssl_in_redirect_uri
-            forces_ssl && uri.try(:scheme) == 'http'
-          end
-
-          def native_redirect_uri
-            Doorkeeper.configuration.native_redirect_uri
-          end
-
-          def add_error(attribute, error)
-            scope = 'sequel.errors.models.doorkeeper/application.attributes.redirect_uri'
-            errors.add(attribute, I18n.t(error, scope: scope))
-          end
-        end
-      end
-    end
-  end
-end