class ActionDispatch::Routing::Mapper

def authenticate(scope = nil, block = nil)
  constraints_for(:authenticate!, scope, block) do
    yield
  end
end

def authenticated(scope = nil, block = nil)
  constraints_for(:authenticate?, scope, block) do
    yield
  end
end

def constraints_for(method_to_apply, scope = nil, block = nil)
  constraint = lambda do |request|
    request.env['warden'].send(method_to_apply, scope: scope) &&
      (block.nil? || block.call(request.env["warden"].user(scope)))
  end
  constraints(constraint) do
    yield
  end
end

def devise_confirmation(mapping, controllers) #:nodoc:
  resource :confirmation, only: [:new, :create, :show],
    path: mapping.path_names[:confirmation], controller: controllers[:confirmations]
end

def devise_for(*resources)
  @devise_finalized = false
  raise_no_secret_key unless Devise.secret_key
  options = resources.extract_options!
  options[:as]          ||= @scope[:as]     if @scope[:as].present?
  options[:module]      ||= @scope[:module] if @scope[:module].present?
  options[:path_prefix] ||= @scope[:path]   if @scope[:path].present?
  options[:path_names]    = (@scope[:path_names] || {}).merge(options[:path_names] || {})
  options[:constraints]   = (@scope[:constraints] || {}).merge(options[:constraints] || {})
  options[:defaults]      = (@scope[:defaults] || {}).merge(options[:defaults] || {})
  options[:options]       = @scope[:options] || {}
  options[:options][:format] = false if options[:format] == false
  resources.map!(&:to_sym)
  resources.each do |resource|
    mapping = Devise.add_mapping(resource, options)
    begin
      raise_no_devise_method_error!(mapping.class_name) unless mapping.to.respond_to?(:devise)
    rescue NameError => e
      raise unless mapping.class_name == resource.to_s.classify
      warn "[WARNING] You provided devise_for #{resource.inspect} but there is " \
        "no model #{mapping.class_name} defined in your application"
      next
    rescue NoMethodError => e
      raise unless e.message.include?("undefined method `devise'")
      raise_no_devise_method_error!(mapping.class_name)
    end
    if options[:controllers] && options[:controllers][:omniauth_callbacks]
      unless mapping.omniauthable?
        raise ArgumentError, "Mapping omniauth_callbacks on a resource that is not omniauthable\n" \
          "Please add `devise :omniauthable` to the `#{mapping.class_name}` model"
      end
    end
    routes = mapping.used_routes
    devise_scope mapping.name do
      with_devise_exclusive_scope mapping.fullpath, mapping.name, options do
        routes.each { |mod| send("devise_#{mod}", mapping, mapping.controllers) }
      end
    end
  end
end

def devise_omniauth_callback(mapping, controllers) #:nodoc:
  if mapping.fullpath =~ /:[a-zA-Z_]/
    raise <<-ERROR
 does not support scoping OmniAuth callbacks under a dynamic segment
u have set #{mapping.fullpath.inspect}. You can work around by passing
 :omniauth_callbacks` to the `devise_for` call and extract omniauth
s to another `devise_for` call outside the scope. Here is an example:
vise_for :users, only: :omniauth_callbacks, controllers: {omniauth_callbacks: 'users/omniauth_callbacks'}
ope '/(:locale)', locale: /ru|en/ do
devise_for :users, skip: :omniauth_callbacks
d
  end
  current_scope = @scope.dup
  if @scope.respond_to? :new
    @scope = @scope.new path: nil
  else
    @scope[:path] = nil
  end
  path_prefix = Devise.omniauth_path_prefix || "/#{mapping.fullpath}/auth".squeeze("/")
  set_omniauth_path_prefix!(path_prefix)
  mapping.to.omniauth_providers.each do |provider|
    match "#{path_prefix}/#{provider}",
      to: "#{controllers[:omniauth_callbacks]}#passthru",
      as: "#{provider}_omniauth_authorize",
      via: [:get, :post]
    match "#{path_prefix}/#{provider}/callback",
      to: "#{controllers[:omniauth_callbacks]}##{provider}",
      as: "#{provider}_omniauth_callback",
      via: [:get, :post]
  end
ensure
  @scope = current_scope
end

def devise_password(mapping, controllers) #:nodoc:
  resource :password, only: [:new, :create, :edit, :update],
    path: mapping.path_names[:password], controller: controllers[:passwords]
end

def devise_registration(mapping, controllers) #:nodoc:
  path_names = {
    new: mapping.path_names[:sign_up],
    edit: mapping.path_names[:edit],
    cancel: mapping.path_names[:cancel]
  }
  options = {
    only: [:new, :create, :edit, :update, :destroy],
    path: mapping.path_names[:registration],
    path_names: path_names,
    controller: controllers[:registrations]
  }
  resource :registration, options do
    get :cancel
  end
end

def devise_scope(scope)
  constraint = lambda do |request|
    request.env["devise.mapping"] = Devise.mappings[scope]
    true
  end
  constraints(constraint) do
    yield
  end
end

def devise_session(mapping, controllers) #:nodoc:
  resource :session, only: [], controller: controllers[:sessions], path: "" do
    get   :new,     path: mapping.path_names[:sign_in],  as: "new"
    post  :create,  path: mapping.path_names[:sign_in]
    match :destroy, path: mapping.path_names[:sign_out], as: "destroy", via: mapping.sign_out_via
  end
end

def devise_unlock(mapping, controllers) #:nodoc:
  if mapping.to.unlock_strategy_enabled?(:email)
    resource :unlock, only: [:new, :create, :show],
      path: mapping.path_names[:unlock], controller: controllers[:unlocks]
  end
end

def raise_no_devise_method_error!(klass) #:nodoc:
  raise "#{klass} does not respond to 'devise' method. This usually means you haven't " \
    "loaded your ORM file or it's being loaded too late. To fix it, be sure to require 'devise/orm/YOUR_ORM' " \
    "inside 'config/initializers/devise.rb' or before your application definition in 'config/application.rb'"
end

def raise_no_secret_key #:nodoc:
  raise <<-ERROR
.secret_key was not set. Please add the following to your Devise initializer:
ig.secret_key = '#{SecureRandom.hex(64)}'
 ensure you restarted your application after installing Devise or setting the key.
end

def set_omniauth_path_prefix!(path_prefix) #:nodoc:
  if ::OmniAuth.config.path_prefix && ::OmniAuth.config.path_prefix != path_prefix
    raise "Wrong OmniAuth configuration. If you are getting this exception, it means that either:\n\n" \
      "1) You are manually setting OmniAuth.config.path_prefix and it doesn't match the Devise one\n" \
      "2) You are setting :omniauthable in more than one model\n" \
      "3) You changed your Devise routes/OmniAuth setting and haven't restarted your server"
  else
    ::OmniAuth.config.path_prefix = path_prefix
  end
end

def unauthenticated(scope = nil)
  constraint = lambda do |request|
    not request.env["warden"].authenticate? scope: scope
  end
  constraints(constraint) do
    yield
  end
end

def with_devise_exclusive_scope(new_path, new_as, options) #:nodoc:
  current_scope = @scope.dup
  exclusive = { as: new_as, path: new_path, module: nil }
  exclusive.merge!(options.slice(:constraints, :defaults, :options))
  if @scope.respond_to? :new
    @scope = @scope.new exclusive
  else
    exclusive.each_pair { |key, value| @scope[key] = value }
  end
  yield
ensure
  @scope = current_scope
end