aikotoba 0.2.0 → 0.3.0

data/db/migrate/20211204121532_create_aikotoba_accounts.rb

@@ -1,9 +1,19 @@
 class CreateAikotobaAccounts < ActiveRecord::Migration[6.1]
+  # NOTE: The tables below the "optional features" marker belong to features that are
+  #       disabled by default (Aikotoba.confirmable / .lockable / .recoverable /
+  #       .magic_link_authenticatable all default to false), so they ship commented out.
+  #       Uncomment the block for each feature you enable -- before running db:migrate
+  #       on a fresh install, or in a new migration of your own if you enable the
+  #       feature later.
+  #
+  #       Leaving them commented out is safe: Aikotoba never queries a feature's table
+  #       while that table does not exist, including on Account#destroy! and session
+  #       revocation. The reverse is not true -- enabling a feature's flag without its
+  #       table raises a real database error the first time that feature runs.
   def change
     create_table :aikotoba_accounts do |t|
       t.belongs_to :authenticate_target, polymorphic: true, index: {unique: true}
       t.string :email, null: false, index: {unique: true}
-      t.string :password_digest, null: false
       t.boolean :confirmed, null: false, default: false
       t.integer :failed_attempts, null: false, default: 0
       t.boolean :locked, null: false, default: false
@@ -11,51 +21,85 @@ class CreateAikotobaAccounts < ActiveRecord::Migration[6.1]
       t.timestamps
     end
 
-    create_table :aikotoba_account_sessions do |t|
-      t.belongs_to :aikotoba_account, null: false, foreign_key: true
-      t.string :token, null: false, index: {unique: true}
-      t.string :origin, null: false, default: "browser"
-      t.string :ip_address
-      t.string :user_agent
-      t.datetime :expired_at, null: false
-
-      t.timestamps
-    end
-
-    create_table :aikotoba_account_confirmation_tokens do |t|
+    create_table :aikotoba_account_password_hashes do |t|
       t.belongs_to(
         :aikotoba_account,
-        foreign_key: true, null: false,
-        index: {unique: true, name: "index_account_confirmation_tokens_on_account_id"}
+        null: false, foreign_key: true,
+        index: {unique: true, name: "index_account_password_hashes_on_account_id"}
       )
-      t.string :token, null: false, index: {unique: true}
-      t.datetime :expired_at, null: false
+      t.string :digest, null: false
 
       t.timestamps
     end
 
-    create_table :aikotoba_account_unlock_tokens do |t|
-      t.belongs_to(
-        :aikotoba_account,
-        null: false, foreign_key: true,
-        index: {unique: true, name: "index_account_unlock_tokens_on_account_id"}
-      )
+    create_table :aikotoba_account_sessions do |t|
+      t.belongs_to :aikotoba_account, null: false, foreign_key: true
       t.string :token, null: false, index: {unique: true}
+      t.string :ip_address
+      t.string :user_agent
       t.datetime :expired_at, null: false
 
       t.timestamps
     end
 
-    create_table :aikotoba_account_recovery_tokens do |t|
-      t.belongs_to(
-        :aikotoba_account,
-        null: false, foreign_key: true,
-        index: {unique: true, name: "index_account_recovery_tokens_on_account_id"}
-      )
-      t.string :token, null: false, index: {unique: true}
-      t.datetime :expired_at, null: false
+    # ------------------------------------------------------------------
+    # Optional features -- uncomment the ones you enable. See the NOTE above.
+    # ------------------------------------------------------------------
 
-      t.timestamps
-    end
+    # Aikotoba.confirmable = true
+    #
+    # create_table :aikotoba_account_confirmation_tokens do |t|
+    #   t.belongs_to(
+    #     :aikotoba_account,
+    #     foreign_key: true, null: false,
+    #     index: {unique: true, name: "index_account_confirmation_tokens_on_account_id"}
+    #   )
+    #   t.string :token, null: false, index: {unique: true}
+    #   t.datetime :expired_at, null: false
+    #
+    #   t.timestamps
+    # end
+
+    # Aikotoba.lockable = true
+    #
+    # create_table :aikotoba_account_unlock_tokens do |t|
+    #   t.belongs_to(
+    #     :aikotoba_account,
+    #     null: false, foreign_key: true,
+    #     index: {unique: true, name: "index_account_unlock_tokens_on_account_id"}
+    #   )
+    #   t.string :token, null: false, index: {unique: true}
+    #   t.datetime :expired_at, null: false
+    #
+    #   t.timestamps
+    # end
+
+    # Aikotoba.recoverable = true
+    #
+    # create_table :aikotoba_account_recovery_tokens do |t|
+    #   t.belongs_to(
+    #     :aikotoba_account,
+    #     null: false, foreign_key: true,
+    #     index: {unique: true, name: "index_account_recovery_tokens_on_account_id"}
+    #   )
+    #   t.string :token, null: false, index: {unique: true}
+    #   t.datetime :expired_at, null: false
+    #
+    #   t.timestamps
+    # end
+
+    # Aikotoba.magic_link_authenticatable = true
+    #
+    # create_table :aikotoba_account_magic_link_tokens do |t|
+    #   t.belongs_to(
+    #     :aikotoba_account,
+    #     null: false, foreign_key: true,
+    #     index: {unique: true, name: "index_account_magic_link_tokens_on_account_id"}
+    #   )
+    #   t.string :token, null: false, index: {unique: true}
+    #   t.datetime :expired_at, null: false
+    #
+    #   t.timestamps
+    # end
   end
 end

data/lib/aikotoba/configuration.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/deep_dup"
+require "active_support/core_ext/integer/time"
+require "aikotoba/scopes"
+
+module Aikotoba
+  # NOTE: Every setting, set through Aikotoba.configure and read through Aikotoba.xxx.
+  class Configuration
+    SETTINGS = %i[
+      parent_controller parent_mailer mailer_sender email_format password_pepper
+      password_length_range session_expiry
+      registerable
+      confirmable confirmation_token_expiry confirmation_rate_limit_options
+      lockable max_failed_attempts unlock_token_expiry unlock_rate_limit_options
+      recoverable recovery_token_expiry recovery_rate_limit_options
+      magic_link_authenticatable magic_link_token_expiry magic_link_rate_limit_options
+      encrypted_token
+      scopes
+    ].freeze
+
+    attr_accessor(*SETTINGS)
+
+    def initialize
+      @parent_controller = "ApplicationController"
+      @parent_mailer = "ActionMailer::Base"
+      @mailer_sender = "from@example.com"
+      @email_format = /\A[^\s]+@[^\s]+\z/
+      @password_pepper = "aikotoba-default-pepper"
+      @password_length_range = 8..100
+      @session_expiry = 7.days
+
+      # for Registerable
+      @registerable = true
+
+      # for Confirmable
+      @confirmable = false
+      @confirmation_token_expiry = 1.day
+      @confirmation_rate_limit_options = {}
+
+      # for Lockable
+      @lockable = false
+      @max_failed_attempts = 10
+      @unlock_token_expiry = 1.day
+      @unlock_rate_limit_options = {}
+
+      # for Recoverable
+      @recoverable = false
+      @recovery_token_expiry = 4.hours
+      @recovery_rate_limit_options = {}
+
+      # for MagicLinkAuthenticatable
+      @magic_link_authenticatable = false
+      @magic_link_token_expiry = 15.minutes
+      @magic_link_rate_limit_options = {}
+
+      # for encrypt token
+      @encrypted_token = false
+
+      @scopes = Scopes.new({
+        default: {
+          authenticate_for: nil,
+          root_path: "/",
+          session_key: "aikotoba_session_token",
+          sign_in_path: "/sign_in",
+          sign_out_path: "/sign_out",
+          after_sign_in_path: "/",
+          after_sign_out_path: "/sign_in",
+          sign_up_path: "/sign_up",
+          confirm_path: "/confirm",
+          unlock_path: "/unlock",
+          recover_path: "/recover",
+          magic_link_path: "/magic_link"
+        }
+      })
+    end
+
+    # NOTE: A copy shares nothing with the original, so changing one (scopes, rate limit
+    #       options) leaves the other as it was.
+    def initialize_copy(source)
+      super
+      SETTINGS.each { |name| public_send(:"#{name}=", source.public_send(name).deep_dup) }
+    end
+
+    def default_scope
+      scopes.default_scope
+    end
+
+    # NOTE: Merges into the default scope (does not replace, keeps the other keys).
+    #       Example: config.default_scope = { sign_in_path: "/custom" }
+    def default_scope=(hash)
+      default_scope.merge!(hash)
+    end
+
+    def add_scope(name, config = {})
+      scopes.add(name, config)
+    end
+  end
+end

data/lib/aikotoba/constraints/magic_link_authenticatable_constraint.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Aikotoba::MagicLinkAuthenticatableConstraint
+  def self.matches?(_request)
+    Aikotoba.magic_link_authenticatable
+  end
+end

data/lib/aikotoba/engine.rb

@@ -3,5 +3,18 @@
 module Aikotoba
   class Engine < ::Rails::Engine
     isolate_namespace Aikotoba
+
+    initializer "aikotoba.deprecator" do |app|
+      app.deprecators[:aikotoba] = Aikotoba.deprecator
+    end
+
+    # NOTE: Runs once the host app's initializers (where Aikotoba.configure lives) are done,
+    #       to also catch scopes changed outside configure. Not in config/routes.rb: Rails 8
+    #       draws routes lazily in development and test, so a check there would only fire on
+    #       the first request.
+    config.after_initialize do
+      Aikotoba.scopes.validate!
+      Aikotoba.scopes.warn_rewritten_paths
+    end
   end
 end

data/lib/aikotoba/errors.rb

@@ -3,5 +3,7 @@ module Aikotoba
     class Base < StandardError; end
 
     class NotAvailableException < Base; end
+
+    class InvalidScopeConfiguration < Base; end
   end
 end

data/lib/aikotoba/scope.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "active_support/hash_with_indifferent_access"
+
+module Aikotoba
+  # NOTE: One scope's settings. Still a HashWithIndifferentAccess, so the documented
+  #       Aikotoba.default_scope[:key] / Aikotoba.scopes[:name][:key] reads and writes keep
+  #       working; the methods below answer the questions callers used to ask of the raw hash.
+  class Scope < ActiveSupport::HashWithIndifferentAccess
+    def authenticate_for
+      self[:authenticate_for]
+    end
+
+    # NOTE: A scope restricted by authenticate_for gets no sign-up: its accounts need an
+    #       authenticate_target of that type, which the generic sign-up form can't create.
+    #       Routes and the sign-in page's sign-up link both read this, so they can't disagree.
+    #       blank? (not nil?) matches Account.for_target_type, which treats "" as unrestricted.
+    def registerable?
+      authenticate_for.blank?
+    end
+
+    # NOTE: Whether this is the scope set up for the target type (authenticate_for: "Admin"
+    #       for "Admin"). An unrestricted scope also signs Admins in, but isn't "for" them.
+    def for?(target_type_name)
+      authenticate_for.present? && authenticate_for.to_s == target_type_name.to_s
+    end
+
+    # NOTE: Whether a request path belongs to this scope. Scopable resolves the current
+    #       scope with this, so route_path keeps each route inside it.
+    #       A trailing slash on root_path is ignored, so "/admin/" covers "/admin/sign_in" too.
+    def covers?(path)
+      path == root || path.start_with?("#{root}/")
+    end
+
+    # NOTE: An absolute path with at least one segment ("/admin", "/admin/", "/a/b"), the
+    #       only shape covers? handles: "/" (or unset) would cover every request, and a
+    #       relative or malformed one ("admin", "/admin//") none, not even its own routes.
+    def valid_root_path?
+      self[:root_path].to_s.match?(%r{\A(/[^/\s]+)+/?\z})
+    end
+
+    # NOTE: The path config/routes.rb draws for a path setting: the value as is when it is
+    #       already under root_path, otherwise prefixed with root_path. So a path add_scope
+    #       copied from the default scope (/magic_link in an /admin scope) still lands in this
+    #       scope (/admin/magic_link), and "/admin/..." isn't prefixed twice. Only for routed
+    #       paths; redirect targets like after_sign_in_path may point anywhere.
+    def route_path(key)
+      path = self[key]
+      covers?(path) ? path : File.join(self[:root_path], path)
+    end
+
+    # NOTE: The *_path settings config/routes.rb draws through route_path; the others are
+    #       the scope's own root and redirect targets, which may point anywhere.
+    def route_path_keys
+      keys.select { |key| key.end_with?("_path") } - %w[root_path after_sign_in_path after_sign_out_path]
+    end
+
+    private
+
+    def root
+      self[:root_path].to_s.chomp("/")
+    end
+  end
+end

data/lib/aikotoba/scopes.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "active_support/hash_with_indifferent_access"
+require "aikotoba/scope"
+
+module Aikotoba
+  # NOTE: All scopes, keyed by name. Still a HashWithIndifferentAccess, so Aikotoba.scopes
+  #       keeps its documented Hash behavior; the cross-scope rules live here.
+  class Scopes < ActiveSupport::HashWithIndifferentAccess
+    # NOTE: Not named default: that would override Hash#default(key = nil), which Hash calls
+    #       with the key on every miss (scopes[:typo] raised ArgumentError), and which
+    #       HashWithIndifferentAccess copies into every dup (select, reject, deep_dup), turning
+    #       the default scope into the copy's fallback value for missing keys.
+    def default_scope
+      self[:default]
+    end
+
+    def add(name, config = {})
+      scope = default_scope.merge(config)
+      validate!(merge(name => scope))
+      self[name] = scope
+    end
+
+    # NOTE: The scope whose links an account's emails use: the scope whose authenticate_for
+    #       matches the account's target type (unique, see validate!), else the default.
+    #       Emails are rendered in a job, with no request to tell which scope was used.
+    def name_for(target_type_name)
+      name, _ = find { |_, scope| scope.for?(target_type_name) }
+      name || "default"
+    end
+
+    # NOTE: Run by the Engine after initialization. route_path prefixes any path outside
+    #       root_path; for one inherited from the default scope or written relative that is
+    #       the intent, but an absolute path set on the scope itself was probably meant as is.
+    #       A value equal to the default scope's can't be told from an inherited one, so it is
+    #       treated as inherited.
+    def warn_rewritten_paths(logger = Rails.logger)
+      except(:default).each do |name, scope|
+        scope.route_path_keys.each do |key|
+          path = scope[key]
+          rewritten = !scope.covers?(path)
+          absolute = path.start_with?("/")
+          same_as_default = path == default_scope[key]
+          next unless rewritten && absolute && !same_as_default
+
+          route = scope.route_path(key)
+          logger&.warn("[Aikotoba] #{name}.#{key} #{path.inspect} is drawn as #{route.inspect}; " \
+            "write #{route.inspect} (or a relative path) to silence this.")
+        end
+      end
+    end
+
+    # NOTE: Checked by add, and again after initialization (Engine), to catch default_scope=
+    #       or direct edits made afterwards.
+    def validate!(scopes = self)
+      validate_root_paths!(scopes)
+      validate_unique_authenticate_for!(scopes)
+    end
+
+    private
+
+    # NOTE: An added scope serves the requests its root_path covers (Scope#covers?). One at "/"
+    #       would take over every request, the host app's included, and a malformed one would
+    #       leave its own pages to the default scope. add_scope copies root_path "/" from the
+    #       default scope unless it is set.
+    def validate_root_paths!(scopes)
+      invalid = scopes.except(:default).reject { |_, scope| scope.valid_root_path? }
+      return if invalid.empty?
+
+      details = invalid.map { |name, scope| "#{name} (#{scope[:root_path].inspect})" }.join(", ")
+      raise Errors::InvalidScopeConfiguration,
+        "root_path of an added scope must be an absolute path other than \"/\", like \"/admin\", but is not on: " \
+        "#{details}. add_scope copies root_path \"/\" from the default scope unless you set it."
+    end
+
+    # NOTE: Each authenticate_for may belong to one scope only, so an account's type maps to
+    #       exactly one scope (see name_for).
+    def validate_unique_authenticate_for!(scopes)
+      shared = scopes
+        .select { |_, scope| scope.authenticate_for.present? }
+        .group_by { |_, scope| scope.authenticate_for.to_s }
+        .select { |_, entries| entries.size > 1 }
+      return if shared.empty?
+
+      details = shared.map { |type, entries| "#{type} (#{entries.map(&:first).join(", ")})" }.join("; ")
+      raise Errors::InvalidScopeConfiguration,
+        "authenticate_for must be unique per scope, but is shared: #{details}. " \
+        "add_scope copies authenticate_for from the default scope unless you set it, so set it " \
+        "explicitly on the added scope (nil for an unrestricted scope)."
+    end
+
+    # NOTE: HashWithIndifferentAccess turns every Hash it stores into a plain
+    #       HashWithIndifferentAccess; store a Scope instead, so a scope assigned directly
+    #       (scopes[:name] = {...}) still answers registerable? / for?. :to_hash is the
+    #       conversion back to a plain Hash.
+    def convert_value(value, conversion: nil)
+      return Scope.new(value) if value.is_a?(Hash) && !value.is_a?(Scope) && conversion != :to_hash
+
+      super
+    end
+  end
+end

data/lib/aikotoba/test/authentication_helper.rb

@@ -9,8 +9,8 @@ module Aikotoba
           follow_redirect!
         end
 
-        def aikotoba_sign_in(account)
-          post aikotoba.new_session_path, params: {account: {email: account.email, password: account.password}}
+        def aikotoba_sign_in(account, password:)
+          post aikotoba.new_session_path, params: {account: {email: account.email, password: password}}
           follow_redirect!
         end
       end
@@ -24,10 +24,10 @@ module Aikotoba
           end
         end
 
-        def aikotoba_sign_in(account)
+        def aikotoba_sign_in(account, password:)
           if page.driver.is_a?(Capybara::RackTest::Driver)
             disable_forgery_protection do
-              page.driver.send(:post, aikotoba.new_session_path, account: {email: account.email, password: account.password})
+              page.driver.send(:post, aikotoba.new_session_path, account: {email: account.email, password: password})
             end
           else
             raise NotImplementedError, "Sorry. Only RackTest::Driver is supported as a test helper for Aikotoba's authentication."

data/lib/aikotoba/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Aikotoba
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/aikotoba.rb

@@ -3,83 +3,49 @@
 require "aikotoba/version"
 require "aikotoba/engine"
 require "aikotoba/errors"
+require "aikotoba/configuration"
 
 module Aikotoba
-  DEPRECATOR = ActiveSupport::Deprecation.new("1.0", "Aikotoba")
-
-  mattr_accessor(:parent_controller) { "ApplicationController" }
-  mattr_accessor(:parent_mailer) { "ActionMailer::Base" }
-  mattr_accessor(:mailer_sender) { "from@example.com" }
-  mattr_accessor(:email_format) { /\A[^\s]+@[^\s]+\z/ }
-  mattr_accessor(:password_pepper) { "aikotoba-default-pepper" }
-  mattr_accessor(:password_length_range) { 8..100 }
-  mattr_accessor(:session_expiry) { 7.days }
-  mattr_accessor(:keep_legacy_login_session) { false }
-
-  # for Registerable
-  mattr_accessor(:registerable) { true }
-
-  # for Confirmable
-  mattr_accessor(:confirmable) { false }
-  mattr_accessor(:confirmation_token_expiry) { 1.day }
-  mattr_accessor(:confirmation_rate_limit_options) { {} }
-
-  # for Lockable
-  mattr_accessor(:lockable) { false }
-  mattr_accessor(:max_failed_attempts) { 10 }
-  mattr_accessor(:unlock_token_expiry) { 1.day }
-  mattr_accessor(:unlock_rate_limit_options) { {} }
-
-  # for Recoverable
-  mattr_accessor(:recoverable) { false }
-  mattr_accessor(:recovery_token_expiry) { 4.hours }
-  mattr_accessor(:recovery_rate_limit_options) { {} }
-
-  # for encrypt token
-  mattr_accessor(:encrypted_token) { false }
-
-  mattr_accessor(:scopes) {
-    HashWithIndifferentAccess.new({
-      default: {
-        authenticate_for: nil,
-        root_path: "/",
-        session_key: "aikotoba_session_token",
-        sign_in_path: "/sign_in",
-        sign_out_path: "/sign_out",
-        after_sign_in_path: "/",
-        after_sign_out_path: "/sign_in",
-        sign_up_path: "/sign_up",
-        confirm_path: "/confirm",
-        unlock_path: "/unlock",
-        recover_path: "/recover"
-      }
-    })
-  }
-
-  def self.default_scope
-    scopes[:default]
+  # NOTE: Set every setting in one place:
+  #       Aikotoba.configure do |config|
+  #         config.confirmable = true
+  #         config.add_scope(:admin, { root_path: "/admin", authenticate_for: "Admin" })
+  #       end
+  #       The scopes are checked once the block has set everything, feature flags included.
+  def self.configure
+    yield config
+    scopes.validate!
   end
 
-  # NOTE: Merge configuration into default scope (does not replace, merges with existing keys)
-  #       Example: Aikotoba.default_scope = { sign_in_path: "/custom" }
-  def self.default_scope=(hash)
-    default_scope.merge!(hash)
+  def self.config
+    @config ||= Configuration.new
   end
 
-  def self.add_scope(name, config = {})
-    scopes[name] = default_scope.merge(config)
+  def self.deprecator
+    @deprecator ||= ActiveSupport::Deprecation.new("1.0", "Aikotoba")
   end
 
-  # TODO: Deprecated for compatibility, will be removed in the future
-  default_scope.each do |key, value|
-    define_singleton_method(key) do
-      DEPRECATOR.warn("Aikotoba.#{key} is deprecated. Please use Aikotoba.default_scope[:#{key}] instead.")
-      default_scope[key]
+  # NOTE: Read a setting with Aikotoba.xxx. The Aikotoba.xxx= writers, add_scope and
+  #       default_scope= still work for initializers written before configure existed, but
+  #       are deprecated and will be removed in 1.0.
+  class << self
+    delegate(*Configuration::SETTINGS, :default_scope, to: :config)
+
+    Configuration::SETTINGS.each do |name|
+      define_method(:"#{name}=") do |value|
+        deprecator.warn("Aikotoba.#{name}= is deprecated. Set config.#{name} in Aikotoba.configure instead.")
+        config.public_send(:"#{name}=", value)
+      end
+    end
+
+    def default_scope=(hash)
+      deprecator.warn("Aikotoba.default_scope= is deprecated. Set config.default_scope in Aikotoba.configure instead.")
+      config.default_scope = hash
     end
 
-    define_singleton_method("#{key}=") do |new_value|
-      DEPRECATOR.warn("Aikotoba.#{key}= is deprecated. Please use Aikotoba.default_scope[:#{key}]= instead.")
-      default_scope[key] = new_value
+    def add_scope(name, scope_config = {})
+      deprecator.warn("Aikotoba.add_scope is deprecated. Call config.add_scope in Aikotoba.configure instead.")
+      config.add_scope(name, scope_config)
     end
   end
 end