lockify 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 76ccb3952ec8db598291189dd3eeb1829d30a70bc898875c80f6fbf0ab92df29
+  data.tar.gz: fff2724bd616d40bbc4c80401abd247e552ffd27aa0a6c474781a6182b07ca88
+SHA512:
+  metadata.gz: 8d3d08d984ea634f0518a9f79a207a68aa3a66c9d8c0e71f8bdf27e7d56dcaec7011c28a1745335c119821b45d54628331b0810cc6c786f444e3695abf9b3744
+  data.tar.gz: 3be69e2b3e0a9ae0e04b9399ac6e31332c1010418e6f04f26c4519ac28224fe3bddce761cdba1799f7a4f2c2c702c3e5c74d8e973890d67ba4ff529c5ae10a29

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2024 Liz - soyprogramador.liz.mx
+
+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,87 @@
+# Lockify - Drop-in Replacement for Devise
+
+Lockify es un reemplazo directo y transparente de Devise para Rails 8, diseñado para funcionar sin modificar código existente.
+
+## Instalación
+
+1. Remover Devise del Gemfile:
+```ruby
+# gem 'devise'  # Comentar o eliminar esta línea
+```
+
+2. Agregar Lockify al Gemfile:
+```ruby
+gem 'lockify', path: 'path/to/lockify'
+```
+
+3. Instalar:
+```bash
+bundle install
+rails generate lockify:install
+rails db:migrate
+```
+
+## Compatibilidad con Devise
+
+### Rutas idénticas:
+- `/users/sign_in`
+- `/users/sign_up`
+- `/users/sign_out`
+- `/users/password/new`
+- `/users/password/edit`
+- `/users/confirmation`
+
+### Helpers idénticos:
+- `current_user`
+- `user_signed_in?`
+- `authenticate_user!`
+- `sign_in(user)`
+- `sign_out`
+
+### Controladores compatibles:
+- Variables de instancia: `@user`, `resource`
+- Métodos: `after_sign_in_path_for`, `stored_location_for`
+- Callbacks y filtros funcionan igual
+
+### Vistas compatibles:
+- Misma estructura de directorios
+- Mismos helpers y variables
+- Generador: `rails generate lockify:views`
+
+## Migración desde Devise
+
+1. **Backup de la base de datos**
+2. **Remover Devise del Gemfile**
+3. **Instalar Lockify**:
+   ```bash
+   bundle install
+   rails generate lockify:install
+   rails db:migrate
+   ```
+4. **Listo** - La aplicación funciona igual
+
+## Campos de base de datos
+
+Lockify maneja automáticamente la migración de:
+- `encrypted_password` → `password_digest`
+- Agrega campos faltantes de confirmación, reset, remember, etc.
+
+## Configuración
+
+```ruby
+# config/initializers/lockify.rb
+Lockify.setup do |config|
+  config.password_length = 6..128
+  config.reset_password_within = 6.hours
+  config.maximum_attempts = 20
+end
+```
+
+## Diferencias técnicas
+
+- Usa `has_secure_password` en lugar de `bcrypt` directo
+- Implementación nativa de Rails 8
+- Sin dependencias externas
+- Mejor rendimiento
+
+La transición es **100% transparente** para el usuario final y el código de la aplicación.

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+load "rails/tasks/statistics.rake"
+
+require "bundler/gem_tasks"

data/app/controllers/users/confirmations_controller.rb

@@ -0,0 +1,62 @@
+class Users::ConfirmationsController < ApplicationController
+  def new
+    self.resource = User.new
+  end
+
+  def create
+    self.resource = User.find_by(email: resource_params[:email]&.downcase)
+    
+    if resource
+      if resource.confirmed?
+        set_flash_message!(:notice, :already_confirmed)
+      else
+        resource.send_confirmation_instructions
+        set_flash_message!(:notice, :send_instructions)
+      end
+    else
+      set_flash_message!(:alert, :not_found)
+    end
+    
+    redirect_to new_user_session_path
+  end
+
+  def show
+    self.resource = User.find_by(confirmation_token: params[:confirmation_token])
+    
+    if resource&.confirmation_period_expired?
+      set_flash_message!(:alert, :expired)
+      redirect_to new_user_confirmation_path
+    elsif resource
+      resource.confirm!
+      sign_in(resource)
+      set_flash_message!(:notice, :confirmed)
+      redirect_to after_confirmation_path_for(:user, resource)
+    else
+      set_flash_message!(:alert, :invalid_token)
+      redirect_to new_user_confirmation_path
+    end
+  end
+
+  protected
+
+  def resource_params
+    params.require(:user).permit(:email)
+  end
+
+  def after_confirmation_path_for(resource_name, resource)
+    after_sign_in_path_for(resource)
+  end
+
+  def set_flash_message!(type, key, options = {})
+    message = find_message(key, options)
+    flash[type] = message if message.present?
+  end
+
+  def find_message(key, options = {})
+    I18n.t("lockify.confirmations.#{key}", **options)
+  end
+
+  private
+
+  attr_accessor :resource
+end

data/app/controllers/users/passwords_controller.rb

@@ -0,0 +1,62 @@
+class Users::PasswordsController < ApplicationController
+  def new
+    self.resource = User.new
+  end
+
+  def create
+    self.resource = User.find_by(email: resource_params[:email]&.downcase)
+    
+    if resource&.confirmed?
+      resource.generate_password_reset_token!
+      UserMailer.reset_password_instructions(resource).deliver_now
+    end
+    
+    set_flash_message!(:notice, :send_instructions)
+    redirect_to new_user_session_path
+  end
+
+  def edit
+    self.resource = User.find_by(reset_password_token: params[:reset_password_token])
+    
+    if resource.nil? || !resource.reset_password_period_valid?
+      set_flash_message!(:alert, :expired)
+      redirect_to new_user_password_path
+    end
+  end
+
+  def update
+    self.resource = User.find_by(reset_password_token: params[:user][:reset_password_token])
+    
+    if resource&.reset_password_period_valid?
+      if resource.reset_password!(resource_params[:password], resource_params[:password_confirmation])
+        sign_in(resource)
+        set_flash_message!(:notice, :updated)
+        redirect_to after_sign_in_path_for(resource)
+      else
+        render :edit, status: :unprocessable_entity
+      end
+    else
+      set_flash_message!(:alert, :expired)
+      redirect_to new_user_password_path
+    end
+  end
+
+  protected
+
+  def resource_params
+    params.require(:user).permit(:email, :password, :password_confirmation, :reset_password_token)
+  end
+
+  def set_flash_message!(type, key, options = {})
+    message = find_message(key, options)
+    flash[type] = message if message.present?
+  end
+
+  def find_message(key, options = {})
+    I18n.t("lockify.passwords.#{key}", **options)
+  end
+
+  private
+
+  attr_accessor :resource
+end

data/app/controllers/users/registrations_controller.rb

@@ -0,0 +1,126 @@
+class Users::RegistrationsController < ApplicationController
+  before_action :configure_sign_up_params, only: [:create]
+  before_action :configure_account_update_params, only: [:update]
+
+  def new
+    build_resource
+    redirect_to after_sign_in_path_for(resource) if user_signed_in?
+  end
+
+  def create
+    build_resource(sign_up_params)
+
+    if resource.save
+      if resource.confirmation_required?
+        resource.send_confirmation_instructions
+        set_flash_message!(:notice, :signed_up_but_unconfirmed)
+        redirect_to new_user_session_path
+      else
+        sign_in(resource)
+        set_flash_message!(:notice, :signed_up)
+        respond_with resource, location: after_sign_up_path_for(resource)
+      end
+    else
+      clean_up_passwords resource
+      render :new, status: :unprocessable_entity
+    end
+  end
+
+  def show
+    redirect_to edit_user_registration_path
+  end
+
+  def edit
+    authenticate_user!
+    self.resource = current_user
+  end
+
+  def update
+    authenticate_user!
+    self.resource = current_user
+
+    if update_resource(resource, account_update_params)
+      bypass_sign_in resource, scope: :user
+      set_flash_message!(:notice, :updated)
+      redirect_to after_update_path_for(resource)
+    else
+      clean_up_passwords resource
+      render :edit, status: :unprocessable_entity
+    end
+  end
+
+  def destroy
+    authenticate_user!
+    resource = current_user
+    resource.destroy
+    sign_out(:user)
+    set_flash_message!(:notice, :destroyed)
+    redirect_to after_sign_out_path_for(:user)
+  end
+
+  protected
+
+  def build_resource(hash = {})
+    self.resource = User.new(hash)
+  end
+
+  def sign_up_params
+    params.require(:user).permit(:email, :password, :password_confirmation)
+  end
+
+  def account_update_params
+    params.require(:user).permit(:email, :password, :password_confirmation, :current_password)
+  end
+
+  def configure_sign_up_params
+    # Override in application if needed
+  end
+
+  def configure_account_update_params
+    # Override in application if needed
+  end
+
+  def after_sign_up_path_for(resource)
+    after_sign_in_path_for(resource)
+  end
+
+  def after_update_path_for(resource)
+    edit_user_registration_path
+  end
+
+  def update_resource(resource, params)
+    if params[:password].present?
+      resource.update(params)
+    else
+      params.delete(:password)
+      params.delete(:password_confirmation)
+      resource.update_without_password(params)
+    end
+  end
+
+  def clean_up_passwords(resource)
+    resource.password = nil
+    resource.password_confirmation = nil
+  end
+
+  def bypass_sign_in(resource, options = {})
+    sign_in(resource, options)
+  end
+
+  def respond_with(resource, _opts = {})
+    redirect_to after_sign_up_path_for(resource)
+  end
+
+  def set_flash_message!(type, key, options = {})
+    message = find_message(key, options)
+    flash[type] = message if message.present?
+  end
+
+  def find_message(key, options = {})
+    I18n.t("lockify.registrations.#{key}", **options)
+  end
+
+  private
+
+  attr_accessor :resource
+end

data/app/controllers/users/sessions_controller.rb

@@ -0,0 +1,68 @@
+class Users::SessionsController < ApplicationController
+  before_action :configure_sign_in_params, only: [:create]
+  before_action :authenticate_user!, only: [:destroy]
+
+  def new
+    redirect_to after_sign_in_path_for(:user) if user_signed_in?
+  end
+
+  def create
+    self.resource = User.find_by(email: sign_in_params[:email]&.downcase)
+    
+    if resource&.authenticate(sign_in_params[:password])
+      if resource.valid_for_authentication?
+        resource.failed_attempts = 0 if resource.respond_to?(:failed_attempts=)
+        resource.save(validate: false) if resource.respond_to?(:failed_attempts)
+        
+        sign_in(resource, remember_me: sign_in_params[:remember_me] == '1')
+        respond_with resource, location: after_sign_in_path_for(resource)
+      else
+        set_flash_message!(:alert, :unconfirmed) unless resource.confirmed?
+        set_flash_message!(:alert, :locked) if resource.access_locked?
+        redirect_to new_user_session_path
+      end
+    else
+      resource&.increment_failed_attempts
+      set_flash_message!(:alert, :invalid)
+      render :new, status: :unprocessable_entity
+    end
+  end
+
+  def destroy
+    signed_out = (user_signed_in?)
+    sign_out(:user)
+    set_flash_message!(:notice, :signed_out) if signed_out
+    respond_to_on_destroy
+  end
+
+  protected
+
+  def sign_in_params
+    params.require(:user).permit(:email, :password, :remember_me)
+  end
+
+  def configure_sign_in_params
+    # Override in application if needed
+  end
+
+  def respond_with(resource, _opts = {})
+    redirect_to after_sign_in_path_for(resource)
+  end
+
+  def respond_to_on_destroy
+    redirect_to after_sign_out_path_for(:user)
+  end
+
+  def set_flash_message!(type, key, options = {})
+    message = find_message(key, options)
+    flash[type] = message if message.present?
+  end
+
+  def find_message(key, options = {})
+    I18n.t("lockify.sessions.#{key}", **options)
+  end
+
+  private
+
+  attr_accessor :resource
+end

data/app/mailers/user_mailer.rb

@@ -0,0 +1,21 @@
+class UserMailer < ApplicationMailer
+  def confirmation_instructions(user)
+    @user = user
+    @confirmation_url = user_confirmation_url(confirmation_token: @user.confirmation_token)
+    
+    mail(
+      to: @user.email,
+      subject: I18n.t('lockify.mailer.confirmation_instructions.subject')
+    )
+  end
+
+  def reset_password_instructions(user)
+    @user = user
+    @reset_password_url = edit_user_password_url(reset_password_token: @user.reset_password_token)
+    
+    mail(
+      to: @user.email,
+      subject: I18n.t('lockify.mailer.reset_password_instructions.subject')
+    )
+  end
+end

data/app/models/concerns/lockify_user.rb

@@ -0,0 +1,138 @@
+module LockifyUser
+  extend ActiveSupport::Concern
+
+  included do
+    has_secure_password validations: false
+
+    validates :email, presence: true, uniqueness: true, format: { with: Lockify.email_regexp }
+    validates :password, length: Lockify.password_length, allow_nil: true, confirmation: true
+
+    before_create :generate_confirmation_token, if: :confirmation_required?
+    before_save :downcase_email
+  end
+
+  def confirmed?
+    !!confirmed_at
+  end
+
+  def confirmation_required?
+    respond_to?(:confirmation_token)
+  end
+
+  def confirmation_period_expired?
+    return false unless respond_to?(:confirmation_sent_at)
+    return false unless Lockify.confirm_within
+    confirmation_sent_at && confirmation_sent_at.utc <= Lockify.confirm_within.ago
+  end
+
+  def confirm!
+    if respond_to?(:confirmed_at=)
+      self.confirmed_at = Time.current
+      self.confirmation_token = nil if respond_to?(:confirmation_token=)
+      save(validate: false)
+    end
+  end
+
+  def send_confirmation_instructions
+    generate_confirmation_token
+    save(validate: false)
+    UserMailer.confirmation_instructions(self).deliver_now
+  end
+
+  def generate_password_reset_token!
+    if respond_to?(:reset_password_token=)
+      self.reset_password_token = SecureRandom.urlsafe_base64
+      self.reset_password_sent_at = Time.current
+      save(validate: false)
+    end
+  end
+
+  def reset_password_period_valid?
+    return false unless respond_to?(:reset_password_sent_at)
+    reset_password_sent_at && reset_password_sent_at.utc >= Lockify.reset_password_within.ago
+  end
+
+  def reset_password!(new_password, new_password_confirmation = nil)
+    self.password = new_password
+    self.password_confirmation = new_password_confirmation || new_password
+    
+    if respond_to?(:reset_password_token=)
+      self.reset_password_token = nil
+      self.reset_password_sent_at = nil
+    end
+    
+    save
+  end
+
+  def remember_me!
+    if respond_to?(:remember_token=)
+      self.remember_token = SecureRandom.urlsafe_base64
+      self.remember_created_at = Time.current if respond_to?(:remember_created_at=)
+      save(validate: false)
+    end
+  end
+
+  def forget_me!
+    if respond_to?(:remember_token=)
+      self.remember_token = nil
+      self.remember_created_at = nil if respond_to?(:remember_created_at=)
+      save(validate: false)
+    end
+  end
+
+  def rememberable_value
+    remember_token if respond_to?(:remember_token)
+  end
+
+  def rememberable_options
+    {}
+  end
+
+  def lock_access!
+    if respond_to?(:locked_at=)
+      self.locked_at = Time.current
+      save(validate: false)
+    end
+  end
+
+  def unlock_access!
+    if respond_to?(:locked_at=)
+      self.locked_at = nil
+      self.failed_attempts = 0 if respond_to?(:failed_attempts=)
+      save(validate: false)
+    end
+  end
+
+  def access_locked?
+    return false unless respond_to?(:locked_at)
+    !!locked_at
+  end
+
+  def increment_failed_attempts
+    if respond_to?(:failed_attempts)
+      self.failed_attempts ||= 0
+      self.failed_attempts += 1
+      lock_access! if failed_attempts >= Lockify.maximum_attempts
+      save(validate: false)
+    end
+  end
+
+  def valid_for_authentication?
+    return false if respond_to?(:confirmed_at) && !confirmed?
+    return false if access_locked?
+    true
+  end
+
+  private
+
+  def generate_confirmation_token
+    if respond_to?(:confirmation_token=)
+      self.confirmation_token = SecureRandom.urlsafe_base64
+      self.confirmation_sent_at = Time.current if respond_to?(:confirmation_sent_at=)
+    end
+  end
+
+  def downcase_email
+    self.email = email.downcase if email.present?
+  end
+end

data/app/views/lockify/confirmations/new.html.erb

@@ -0,0 +1,16 @@
+<h2><%= t('.resend_confirmation_instructions') %></h2>
+
+<%= form_with(model: resource, as: :user, url: user_confirmation_path, local: true) do |f| %>
+  <%= render "lockify/shared/error_messages", resource: resource %>
+
+  <div class="field">
+    <%= f.label :email %>
+    <%= f.email_field :email, autofocus: true, autocomplete: "email", value: (resource.pending_reconfirmation? ? resource.unconfirmed_email : resource.email) %>
+  </div>
+
+  <div class="actions">
+    <%= f.submit t('.resend_confirmation_instructions') %>
+  </div>
+<% end %>
+
+<%= render "lockify/shared/links" %>

data/app/views/lockify/passwords/edit.html.erb

@@ -0,0 +1,25 @@
+<h2><%= t('.change_your_password') %></h2>
+
+<%= form_with(model: resource, as: :user, url: user_password_path, local: true) do |f| %>
+  <%= render "lockify/shared/error_messages", resource: resource %>
+  <%= f.hidden_field :reset_password_token %>
+
+  <div class="field">
+    <%= f.label :password, t('.new_password') %>
+    <% if @minimum_password_length %>
+      <em>(<%= @minimum_password_length %> characters minimum)</em>
+    <% end %>
+    <%= f.password_field :password, autofocus: true, autocomplete: "new-password" %>
+  </div>
+
+  <div class="field">
+    <%= f.label :password_confirmation, t('.confirm_new_password') %>
+    <%= f.password_field :password_confirmation, autocomplete: "new-password" %>
+  </div>
+
+  <div class="actions">
+    <%= f.submit t('.change_my_password') %>
+  </div>
+<% end %>
+
+<%= render "lockify/shared/links" %>

data/app/views/lockify/passwords/new.html.erb

@@ -0,0 +1,16 @@
+<h2><%= t('.forgot_your_password') %></h2>
+
+<%= form_with(model: resource, as: :user, url: user_password_path, local: true) do |f| %>
+  <%= render "lockify/shared/error_messages", resource: resource %>
+
+  <div class="field">
+    <%= f.label :email %>
+    <%= f.email_field :email, autofocus: true, autocomplete: "email" %>
+  </div>
+
+  <div class="actions">
+    <%= f.submit t('.send_me_reset_password_instructions') %>
+  </div>
+<% end %>
+
+<%= render "lockify/shared/links" %>

data/app/views/lockify/registrations/new.html.erb

@@ -0,0 +1,29 @@
+<h2><%= t('.sign_up') %></h2>
+
+<%= form_with(model: resource, as: :user, url: user_registration_path, local: true) do |f| %>
+  <%= render "lockify/shared/error_messages", resource: resource %>
+
+  <div class="field">
+    <%= f.label :email %>
+    <%= f.email_field :email, autofocus: true, autocomplete: "email" %>
+  </div>
+
+  <div class="field">
+    <%= f.label :password %>
+    <% if @minimum_password_length %>
+    <em>(<%= @minimum_password_length %> characters minimum)</em>
+    <% end %>
+    <%= f.password_field :password, autocomplete: "new-password" %>
+  </div>
+
+  <div class="field">
+    <%= f.label :password_confirmation %>
+    <%= f.password_field :password_confirmation, autocomplete: "new-password" %>
+  </div>
+
+  <div class="actions">
+    <%= f.submit t('.sign_up') %>
+  </div>
+<% end %>
+
+<%= render "lockify/shared/links" %>