rodauth 0.10.0 → 1.0.0

data/lib/roda/plugins/rodauth/base.rb

@@ -1,428 +0,0 @@
-class Roda
-  module RodaPlugins
-    module Rodauth
-      Base = Feature.define(:base) do
-        auth_value_methods(
-          :account_id,
-          :account_model,
-          :account_open_status_value,
-          :account_password_hash_column,
-          :account_status_id,
-          :account_unverified_status_value,
-          :default_redirect,
-          :email_from,
-          :email_subject_prefix,
-          :login_column,
-          :login_confirm_label,
-          :login_confirm_param,
-          :login_label,
-          :login_param,
-          :logins_do_not_match_message,
-          :no_matching_login_message,
-          :password_confirm_label,
-          :password_confirm_param,
-          :password_does_not_meet_requirements_message,
-          :password_hash_column,
-          :password_hash_cost,
-          :password_hash_table,
-          :password_label,
-          :password_minimum_length,
-          :password_param,
-          :passwords_do_not_match_message,
-          :prefix,
-          :require_login_notice_message,
-          :require_login_redirect,
-          :session_key,
-          :skip_status_checks?,
-          :title_instance_variable
-        )
-
-        auth_methods(
-          :account_from_login,
-          :account_from_session,
-          :account_id_value,
-          :account_session_value,
-          :after_close_account,
-          :already_logged_in,
-          :clear_session,
-          :create_email,
-          :email_to,
-          :logged_in?,
-          :login_errors_message,
-          :login_required,
-          :open_account?,
-          :password_hash,
-          :password_meets_requirements?,
-          :random_key,
-          :session_value,
-          :set_error_flash,
-          :set_notice_flash,
-          :set_password,
-          :set_redirect_error_flash,
-          :set_title,
-          :unverified_account_message,
-          :update_session
-        )
-
-        attr_reader :scope
-        attr_reader :account
-
-        def initialize(scope)
-          @scope = scope
-        end
-
-        def features
-          self.class.features
-        end
-
-        def request
-          scope.request
-        end
-
-        def response
-          scope.response
-        end
-
-        def session
-          scope.session
-        end
-
-        def flash
-          scope.flash
-        end
-
-        # Overridable methods
-
-        def account_id_value
-          account.send(account_id)
-        end
-        alias account_session_value account_id_value
-
-        def session_value
-          session[session_key]
-        end
-
-        def account_status_id_value
-          account.send(account_status_id)
-        end
-
-        def _account_from_login(login)
-          @account = account_from_login(login)
-        end
-
-        def account_from_login(login)
-          ds = account_model.where(login_column=>login)
-          ds = ds.where(account_status_id=>[account_unverified_status_value, account_open_status_value]) unless skip_status_checks?
-          ds.first
-        end
-
-        def open_account?
-          skip_status_checks? || account_status_id_value == account_open_status_value 
-        end
-
-        def unverified_account_message
-          "unverified account, please verify account before logging in"
-        end
-
-        def update_session
-          clear_session
-          session[session_key] = account_session_value
-        end
-
-        def check_before(feature)
-          meth = :"check_before_#{feature.feature_name}"
-          if respond_to?(meth)
-            send(meth)
-          elsif feature.account_required?
-            require_account
-          elsif logged_in?
-            already_logged_in 
-          end
-        end
-
-        def account_model
-          ::Account
-        end
-
-        def db
-          account_model.db
-        end
-
-        # If the account_password_hash_column is set, the password hash is verified in
-        # ruby, it will not use a database function to do so, it will check the password
-        # hash using bcrypt.
-        def account_password_hash_column
-          nil
-        end
-
-        def already_logged_in
-          nil
-        end
-
-        def clear_session
-          session.clear
-        end
-
-        def default_redirect
-          '/'
-        end
-
-        def require_login_redirect
-          "#{prefix}/login"
-        end
-
-        def require_login_notice_message
-          "Please login to continue"
-        end
-
-        def prefix
-          ''
-        end
-
-        def login_required
-          set_notice_flash require_login_notice_message
-          request.redirect require_login_redirect
-        end
-
-        def random_key
-          require 'securerandom'
-          if RUBY_VERSION >= '1.9'
-            SecureRandom.urlsafe_base64(32)
-          else
-            # :nocov:
-            SecureRandom.hex(32)
-            # :nocov:
-          end
-        end
-
-        def title_instance_variable
-          nil
-        end
-
-        def set_title(title)
-          if title_instance_variable
-            scope.instance_variable_set(title_instance_variable, title)
-          end
-        end
-
-        def set_error_flash(message)
-          flash.now[:error] = message
-        end
-
-        def set_redirect_error_flash(message)
-          flash[:error] = message
-        end
-
-        def set_notice_flash(message)
-          flash[:notice] = message
-        end
-
-        def login_column
-          :email
-        end
-
-        def password_hash_column
-          :password_hash
-        end
-
-        def password_hash_table
-          :account_password_hashes
-        end
-
-        def no_matching_login_message
-          "no matching login"
-        end
-
-        def logged_in?
-          session[session_key]
-        end
-
-        def require_login
-          login_required unless logged_in?
-        end
-
-        def require_account
-          require_login
-          unless _account_from_session
-            clear_session
-            login_required
-          end
-        end
-
-        def login_param
-          'login'
-        end
-
-        def login_confirm_param
-          'login-confirm'
-        end
-
-        def login_label
-          'Login'
-        end
-
-        def login_confirm_label
-          "Confirm #{login_label}"
-        end
-
-        def password_label
-          'Password'
-        end
-
-        def password_confirm_label
-          "Confirm #{password_label}"
-        end
-
-        def login_errors_message
-          if errors = account.errors.on(login_column)
-            errors.join(', ')
-          end
-        end
-
-        def logins_do_not_match_message
-          'logins do not match'
-        end
-
-        def password_param
-          'password'
-        end
-
-        def password_confirm_param
-          'password-confirm'
-        end
-
-        def session_key
-          :account_id
-        end
-
-        def account_id
-          :id
-        end
-
-        def account_status_id
-          :status_id
-        end
-
-        def passwords_do_not_match_message
-          'passwords do not match'
-        end
-
-        def password_does_not_meet_requirements_message
-          "invalid password, does not meet requirements (minimum #{password_minimum_length} characters)"
-        end
-
-        def password_minimum_length
-          6
-        end
-
-        def password_meets_requirements?(password)
-          password_minimum_length <= password.length
-        end
-
-        def account_unverified_status_value
-          1
-        end
-
-        def account_open_status_value
-          2
-        end
-
-        def account_initial_status_value
-          account_open_status_value
-        end
-
-        def _account_from_session
-          @account = account_from_session
-        end
-
-        def account_from_session
-          ds = account_model.where(account_id=>scope.session[session_key])
-          ds = ds.where(account_status_id=>account_open_status_value) unless skip_status_checks?
-          ds.first
-        end
-
-        def password_hash_cost
-          require 'bcrypt'
-          if ENV['RACK_ENV'] == 'test'
-            BCrypt::Engine::MIN_COST
-          else
-            # :nocov:
-            BCrypt::Engine::DEFAULT_COST
-            # :nocov:
-          end
-        end
-
-        def password_hash(password)
-          require 'bcrypt'
-          BCrypt::Password.create(password, :cost=>password_hash_cost)
-        end
-
-        def set_password(password)
-          hash = password_hash(password)
-          if account_password_hash_column
-            account.set(account_password_hash_column=>hash).save_changes(:raise_on_save_failure=>true)
-          else
-            if db[password_hash_table].where(account_id=>account_id_value).update(password_hash_column=>hash) == 0
-              db[password_hash_table].insert(account_id=>account_id_value, password_hash_column=>hash)
-            end
-          end
-        end
-
-        def transaction(&block)
-          db.transaction(&block)
-        end
-
-        def email_from
-          "webmaster@#{request.host}"
-        end
-
-        def email_to
-          account.email
-        end
-
-        def create_email(subject, body)
-          require 'mail'
-          m = Mail.new
-          m.from = email_from
-          m.to = email_to
-          m.subject = "#{email_subject_prefix}#{subject}"
-          m.body = body
-          m
-        end
-
-        def email_subject_prefix
-          nil
-        end
-
-        def view(page, title)
-          set_title(title)
-          _view(:view, page)
-        end
-
-        def render(page)
-          _view(:render, page)
-        end
-
-        def skip_status_checks?
-          false
-        end
-
-        def after_close_account
-        end
-
-        private
-
-        def _view(meth, page)
-          auth = self
-          scope.instance_exec do
-            template_opts = find_template(parse_template_opts(page, :locals=>{:rodauth=>auth}))
-            unless File.file?(template_path(template_opts))
-              template_opts[:path] = File.join(File.dirname(__FILE__), '../../../../templates', "#{page}.str")
-            end
-            send(meth, template_opts)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/roda/plugins/rodauth/change_login.rb

@@ -1,48 +0,0 @@
-class Roda
-  module RodaPlugins
-    module Rodauth
-      ChangeLogin = Feature.define(:change_login) do
-        route 'change-login'
-        notice_flash 'Your login has been changed'
-        error_flash 'There was an error changing your login'
-        view 'change-login', 'Change Login'
-        after
-        additional_form_tags
-        button 'Change Login'
-        redirect
-        require_account
-
-        auth_methods :change_login
-
-        get_block do |r, auth|
-          auth.view('change-login', 'Change Login')
-        end
-
-        post_block do |r, auth|
-          if r[auth.login_param] == r[auth.login_confirm_param]
-            auth.transaction do
-              if auth.change_login(r[auth.login_param].to_s)
-                auth.after_change_login
-                auth.set_notice_flash auth.change_login_notice_flash
-                r.redirect(auth.change_login_redirect)
-              else
-                @login_error = auth.login_errors_message
-              end
-            end
-          else
-            @login_error = auth.logins_do_not_match_message
-          end
-
-          auth.set_error_flash auth.change_login_error_flash
-          auth.change_login_view
-        end
-
-        def change_login(login)
-          account.set(login_column=>login).save_changes(:raise_on_failure=>false)
-        end
-      end
-    end
-  end
-end
-
-