with_accounts 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0dfa1a4d1da17c960a154c17640b0d3d493c1edb625effb5833a3b0f11a02ed1
+  data.tar.gz: 86e20e8238250680d21155e061335571b4ca917378b690d8efb98f36a7aa94eb
+SHA512:
+  metadata.gz: 7ba1aa74f8316fff0988ae5d548e2d1fa1067b4a19a8f247da2d6fb6913105eae057a1ffca83522e331c28f6b3a0c33680e679ee2c17333215fe2462e0c3cb4f
+  data.tar.gz: b9593e21e1a3098e3fc201ab40425300443d1bdf833d64d8d7dbf33850d218c71c8cf8a589d5cd268c8f359e22bad7868610460b786d2a7cb6e2f5c501ea748b

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2023 М.Забодаев
+
+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,28 @@
+# WithAccounts
+Short description and motivation.
+
+## Usage
+How to use my plugin.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem "with_accounts"
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install with_accounts
+```
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

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

data/app/controllers/with_accounts/application_controller.rb

@@ -0,0 +1,54 @@
+module WithAccounts
+  class ApplicationController < ActionController::API
+    include ErrorsHelpers
+
+    before_action :snake_case_params
+    after_action :set_json_content_type
+    around_action :render_around_action_errors
+
+    @@log_errors = ENV['LOG_ERRORS'] == 'true' ||
+      Rails.env.in?(%w[development test staging]) ||
+      false
+
+    def render_errors(errors_hash, status = :bad_request)
+      if @@log_errors
+        logger.warn(errors_hash)
+        render_low_camel_cased({ errors: format_errors(errors_hash) }, status)
+      else
+        render body: '{}', status: :bad_request
+      end
+    end
+
+    def render_low_camel_cased(hash_or_array_of_hashes, status)
+      low_camelized = case hash_or_array_of_hashes
+                      when Hash
+                        hash_or_array_of_hashes.deep_transform_keys { _1.to_s.camelize(:lower) }
+                      when Array
+                        hash_or_array_of_hashes.map { |hash| hash.deep_transform_keys { _1.to_s.camelize(:lower) } }
+                      else
+                        raise StandardError
+                      end
+      st = status.is_a?(Integer) ? status : status.to_sym
+      render json: low_camelized, status: st
+    end
+
+    def set_json_content_type
+      response.headers['Content-Type'] = 'application/json; charset=utf-8'
+    end
+
+    def render_around_action_errors
+      yield
+    rescue StandardError => e
+      message = 'filtered'
+      if @@log_errors
+        message = Rails.env.production? ? e.message : e.full_message
+      end
+      render_low_camel_cased({ errors: {internal_server_error: message} }, :internal_server_error)
+    end
+
+    def snake_case_params
+      params.to_snake_case!
+    end
+
+  end
+end

data/app/controllers/with_accounts/meaningful_controller.rb

@@ -0,0 +1,44 @@
+module WithAccounts
+  class MeaningfulController < ApplicationController
+    def not_found
+      render body: '{"errors": "not found"}', status: 404
+    end
+
+    def create_login_invitation
+      performance = LoginInvitationsCreating::Scenario.new(params: params).act_out!
+      (render_errors(performance.errors) && return) unless performance.success?
+
+      render status: :no_content
+    end
+
+    def create_tokens
+      data = { access_token: '', refresh_token: '' }
+      performance = Jwts::RefreshTokensCreating::Scenario.new(params: params).act_out!
+      (render_errors(performance.errors) && return) unless performance.success?
+
+      data.merge!(refresh_token: performance.stage.new_token)
+      performance = Jwts::AccessTokensCreating::Scenario.new(params: { refresh_token: data[:refresh_token] }).act_out!
+      (render_errors(performance.errors) && return) unless performance.success?
+
+      data.merge!(access_token: performance.stage.new_token)
+      render_low_camel_cased(data, :created)
+    end
+
+    def create_access_token
+      data = { access_token: '' }
+      performance = Jwts::AccessTokensCreating::Scenario.new(params: params).act_out!
+      (render_errors(performance.errors) && return) unless performance.success?
+
+      data.merge!(access_token: performance.stage.new_token)
+      render_low_camel_cased(data, :created)
+    end
+
+    def set_password
+      performance = PasswordsCreating::Scenario.new(params: params).act_out!
+      (render_errors(performance.errors) && return) unless performance.success?
+
+      render_low_camel_cased({}, :created)
+    end
+
+  end
+end

data/app/models/with_accounts/account.rb

@@ -0,0 +1,41 @@
+module WithAccounts
+  class Account < ApplicationRecord
+    belongs_to :user, class_name: 'User'
+
+    has_secure_password :password
+    has_secure_password :refresh_token
+
+    LOGIN_INVITATION_TTL = 3.hours
+    REFRESH_TOKEN_TTL = 12.hours
+    ACCESS_TOKEN_TTL = 1.minute
+
+    scope :ready_to_login, lambda { |_|
+      where.not(login_invitation: '', password_set_at: nil)
+    }
+
+    scope :ready_to_set_password, lambda { |_|
+      where(password_set_at: nil).where('password_set_before, > ?', Time.now)
+    }
+
+    scope :ready_to_change_password, lambda { |_|
+      where.not(password_change_invitation: '', password_set_at: nil).where('password_change_before, > ?', Time.now)
+    }
+
+    def cipher_decipher(type, timestamp_attr_name)
+      timestamp = public_send(timestamp_attr_name) || created_at
+      cipher = OpenSSL::Cipher.new('aes-256-cbc')
+      case type
+      when :encrypt
+        cipher.encrypt
+      when :decrypt
+        cipher.decrypt
+      else
+        raise StandardError
+      end
+      cipher.tap do
+        _1.key = id.byteslice(0..31)
+        _1.iv = "#{timestamp&.strftime('%Y%m%d%H%M%S%6N')}---".byteslice(0..15)
+      end
+    end
+  end
+end

data/app/models/with_accounts/application_record.rb

@@ -0,0 +1,5 @@
+module WithAccounts
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/scenarios/with_accounts/jwts/access_tokens_creating/check_refresh_token.rb

@@ -0,0 +1,23 @@
+module WithAccounts
+  module Jwts
+    module AccessTokensCreating
+      class CheckRefreshToken < LetsDoThis::Act
+        include ErrorsHelpers
+        HMAC_SECRET = ENV.fetch('HMAC_SECRET', 'stemporalyasdasdasdasdasdjdhfjds').byteslice(0..31)
+
+        def instructions(stage)
+          refresh_token = stage.params[:refresh_token]
+          decoded_token = JWT.decode(refresh_token,
+                                     HMAC_SECRET,
+                                     true,
+                                     { algorithm: 'HS256' })
+          token_data = decoded_token.reduce({}, :merge)
+          { said: token_data['said'] }
+        rescue JWT::DecodeError
+          errors.add(error_key, 'err')
+          NOTHING_NEW
+        end
+      end
+    end
+  end
+end

data/app/scenarios/with_accounts/jwts/access_tokens_creating/find_and_check_account.rb

@@ -0,0 +1,30 @@
+module WithAccounts
+  module Jwts
+    module AccessTokensCreating
+      class FindAndCheckAccount < LetsDoThis::Act
+        include ErrorsHelpers
+
+        def instructions(stage)
+          unless stage.said.present?
+            errors.add(error_key, 'err')
+            return NOTHING_NEW
+          end
+
+          saved_72_char_version = stage.params[:refresh_token][0..71]
+
+          account = Account.joins(:user)
+                           .where('users.disabled': false)
+                           .find_by_said(stage.said)
+                           &.authenticate_refresh_token(saved_72_char_version)
+
+          unless account
+            errors.add(error_key, 'err')
+            return NOTHING_NEW
+          end
+
+          { account: account }
+        end
+      end
+    end
+  end
+end

data/app/scenarios/with_accounts/jwts/access_tokens_creating/prepare_access_token_payload.rb

@@ -0,0 +1,15 @@
+module WithAccounts
+  module Jwts
+    module AccessTokensCreating
+      class PrepareAccessTokenPayload < LetsDoThis::Act
+
+        def instructions(stage)
+          payload = { exp: (Time.now + Account::ACCESS_TOKEN_TTL).to_i,
+                      said: stage.account.said }
+
+          { payload: payload }
+        end
+      end
+    end
+  end
+end

data/app/scenarios/with_accounts/jwts/access_tokens_creating/scenario.rb

@@ -0,0 +1,15 @@
+module WithAccounts
+  module Jwts
+    module AccessTokensCreating
+      class Scenario < LetsDoThis::Scenario
+        ACT_SEQUENCE = [
+          CheckRefreshToken,
+          FindAndCheckAccount,
+          PrepareAccessTokenPayload,
+          CreateToken
+        ].freeze
+        STAGE_ATTRS_WHITELIST = %i[params said account payload new_token].freeze
+      end
+    end
+  end
+end

data/app/scenarios/with_accounts/jwts/create_token.rb

@@ -0,0 +1,10 @@
+module WithAccounts
+  module Jwts
+    class CreateToken < LetsDoThis::Act
+      HMAC_SECRET = ENV.fetch('HMAC_SECRET', 'stemporalyasdasdasdasdasdjdhfjds').byteslice(0..31)
+      def instructions(stage)
+        { new_token: (JWT.encode stage.payload, HMAC_SECRET, 'HS256') }
+      end
+    end
+  end
+end

data/app/scenarios/with_accounts/jwts/refresh_tokens_creating/check_login_invitation.rb

@@ -0,0 +1,32 @@
+module WithAccounts
+  module Jwts
+    module RefreshTokensCreating
+      class CheckLoginInvitation < LetsDoThis::Act
+        include ErrorsHelpers
+
+        def instructions(stage)
+          login_invitation = stage.params[:invitation]
+          account = Account.joins(:user)
+                           .where('users.disabled': false)
+                           .find_by_login_invitation(login_invitation)
+          unless account
+            errors.add(error_key, 'err')
+            return NOTHING_NEW
+          end
+
+          encrypted = Base64.urlsafe_decode64(login_invitation)
+          decipher = account.cipher_decipher(:decrypt, :login_at)
+          plain = decipher.update(encrypted) + decipher.final
+          deadline = Time.at(plain.to_i)
+
+          if Time.now > deadline
+            errors.add(error_key, 'err')
+            return NOTHING_NEW
+          end
+
+          { account: account }
+        end
+      end
+    end
+  end
+end

data/app/scenarios/with_accounts/jwts/refresh_tokens_creating/prepare_refresh_token_payload.rb

@@ -0,0 +1,15 @@
+module WithAccounts
+  module Jwts
+    module RefreshTokensCreating
+      class PrepareRefreshTokenPayload < LetsDoThis::Act
+
+        def instructions(stage)
+          payload = { exp: (Time.now + Account::REFRESH_TOKEN_TTL).to_i,
+                      said: stage.account.said }
+
+          { payload: payload }
+        end
+      end
+    end
+  end
+end

data/app/scenarios/with_accounts/jwts/refresh_tokens_creating/scenario.rb

@@ -0,0 +1,15 @@
+module WithAccounts
+  module Jwts
+    module RefreshTokensCreating
+      class Scenario < LetsDoThis::Scenario
+        ACT_SEQUENCE = [
+          CheckLoginInvitation,
+          PrepareRefreshTokenPayload,
+          CreateToken,
+          UpdateAccount
+        ].freeze
+        STAGE_ATTRS_WHITELIST = %i[params account payload new_token].freeze
+      end
+    end
+  end
+end

data/app/scenarios/with_accounts/jwts/refresh_tokens_creating/update_account.rb

@@ -0,0 +1,21 @@
+module WithAccounts
+  module Jwts
+    module RefreshTokensCreating
+      class UpdateAccount < LetsDoThis::Act
+
+        def instructions(stage)
+          saved_72_char_version = stage.new_token[0..71]
+
+          update = stage.account.update(login_invitation: '',
+                                        refresh_token: saved_72_char_version,
+                                        refresh_token_confirmation: saved_72_char_version,
+                                        login_at: Time.now)
+
+          errors.add(error_key, 'err') unless update
+
+          NOTHING_NEW
+        end
+      end
+    end
+  end
+end

data/app/scenarios/with_accounts/login_invitations_creating/check_params.rb

@@ -0,0 +1,20 @@
+module WithAccounts
+  module LoginInvitationsCreating
+    class CheckParams < LetsDoThis::Act
+      include ErrorsHelpers
+
+      def instructions(stage)
+        email = stage.params[:email].to_s
+        password = stage.params[:password].to_s
+
+        # TODO
+        if 1 != 1
+          errors.add(error_key, 'err')
+          return NOTHING_NEW
+        end
+
+        { email: email, password: password }
+      end
+    end
+  end
+end

data/app/scenarios/with_accounts/login_invitations_creating/find_and_check_account.rb

@@ -0,0 +1,21 @@
+module WithAccounts
+  module LoginInvitationsCreating
+    class FindAndCheckAccount < LetsDoThis::Act
+      include ErrorsHelpers
+
+      def instructions(stage)
+        account = Account.ready_to_login(:_)
+                         .joins(:user)
+                         .where('users.disabled': false, 'users.email': stage.email)
+                         .take&.authenticate(stage.password)
+
+        unless account
+          errors.add(error_key, 'err')
+          return NOTHING_NEW
+        end
+
+        { account: account }
+      end
+    end
+  end
+end

data/app/scenarios/with_accounts/login_invitations_creating/scenario.rb

@@ -0,0 +1,13 @@
+module WithAccounts
+  module LoginInvitationsCreating
+    class Scenario < LetsDoThis::Scenario
+      ACT_SEQUENCE = [
+        CheckParams,
+        FindAndCheckAccount,
+        UpdateAccountLoginInvitation,
+        SendEmailToUser
+      ].freeze
+      STAGE_ATTRS_WHITELIST = %i[params email password account login_invitation].freeze
+    end
+  end
+end

data/app/scenarios/with_accounts/login_invitations_creating/send_email_to_user.rb

@@ -0,0 +1,15 @@
+module WithAccounts
+  module LoginInvitationsCreating
+    class SendEmailToUser < LetsDoThis::Act
+      include ErrorsHelpers
+
+      def instructions(stage)
+        stage.account.user.send_email_with_login_invitation(stage.login_invitation)
+        NOTHING_NEW
+      rescue StandardError
+        errors.add(error_key, 'err')
+        NOTHING_NEW
+      end
+    end
+  end
+end

data/app/scenarios/with_accounts/login_invitations_creating/update_account_login_invitation.rb

@@ -0,0 +1,24 @@
+module WithAccounts
+  module LoginInvitationsCreating
+    class UpdateAccountLoginInvitation < LetsDoThis::Act
+      include ErrorsHelpers
+
+      def instructions(stage)
+        account = stage.account
+        data = (Time.now + Account::LOGIN_INVITATION_TTL).to_i.to_s
+
+        cipher = account.cipher_decipher(:encrypt, :login_at)
+
+        encrypted = cipher.update(data) + cipher.final
+        new_invitation = Base64.urlsafe_encode64(encrypted, padding: false)
+
+        unless account.update(login_invitation: new_invitation)
+          errors.add(error_key, 'err')
+          return NOTHING_NEW
+        end
+
+        { login_invitation: new_invitation }
+      end
+    end
+  end
+end

data/app/scenarios/with_accounts/passwords_creating/check_params.rb

@@ -0,0 +1,24 @@
+module WithAccounts
+  module PasswordsCreating
+    class CheckParams < LetsDoThis::Act
+      include ErrorsHelpers
+
+      def instructions(stage)
+        password = stage.params[:password]
+        password_confirmation = stage.params[:password_confirmation]
+
+        unless password == password_confirmation
+          errors.add(error_key, 'err')
+          return NOTHING_NEW
+        end
+
+        unless password.to_s.match?(PASSWORD_REGEXP)
+          errors.add(error_key, 'err')
+          return NOTHING_NEW
+        end
+
+        { password: password }
+      end
+    end
+  end
+end

data/app/scenarios/with_accounts/passwords_creating/check_password_set_invitation.rb

@@ -0,0 +1,31 @@
+module WithAccounts
+  module PasswordsCreating
+    class CheckPasswordSetInvitation < LetsDoThis::Act
+      include ErrorsHelpers
+      def instructions(stage)
+        password_set_invitation = stage.params[:invitation]
+        account = Account.ready_to_set_password(:_)
+                         .joins(:user)
+                         .where('users.disabled': false)
+                         .find_by_password_set_invitation(password_set_invitation)
+
+        unless account
+          errors.add(error_key, 'err')
+          return NOTHING_NEW
+        end
+
+        encrypted = Base64.urlsafe_decode64(password_set_invitation)
+        decipher = account.cipher_decipher(:decrypt, :password_set_at)
+        plain = decipher.update(encrypted) + decipher.final
+        deadline = Time.at(plain.to_i)
+
+        if Time.now > deadline
+          errors.add(error_key, 'err')
+          return NOTHING_NEW
+        end
+
+        { account: account }
+      end
+    end
+  end
+end

data/app/scenarios/with_accounts/passwords_creating/scenario.rb

@@ -0,0 +1,12 @@
+module WithAccounts
+  module PasswordsCreating
+    class Scenario < LetsDoThis::Scenario
+      ACT_SEQUENCE = [
+        CheckParams,
+        CheckPasswordSetInvitation,
+        UpdateAccount
+      ].freeze
+      STAGE_ATTRS_WHITELIST = %i[params password account].freeze
+    end
+  end
+end

data/app/scenarios/with_accounts/passwords_creating/update_account.rb

@@ -0,0 +1,28 @@
+module WithAccounts
+  module PasswordsCreating
+    class UpdateAccount < LetsDoThis::Act
+      include ErrorsHelpers
+
+      def instructions(stage)
+        account = stage.account
+
+        account.tap do
+          account.password = stage.password
+          account.password_confirmation = stage.password
+          account.password_set_invitation = ''
+          account.password_set_at = Time.now
+        end
+
+        unless account.save
+          errors.add(error_key, 'err')
+          return NOTHING_NEW
+        end
+
+        { account: account }
+      rescue StandardError
+        errors.add(error_key, 'err')
+        NOTHING_NEW
+      end
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,8 @@
+WithAccounts::Engine.routes.draw do
+  root to: 'meaningful#not_found'
+
+  post '/passwords_setters', to: 'meaningful#set_user_password'
+  post '/invitations', to: 'meaningful#create_login_invitation'
+  post '/tokens', to: 'meaningful#create_tokens'
+  post '/access_tokens', to: 'meaningful#create_access_token'
+end

data/db/migrate/20231004123741_create_with_accounts_accounts.rb

@@ -0,0 +1,20 @@
+class CreateWithAccountsAccounts < ActiveRecord::Migration[7.0]
+  def change
+    create_table :with_accounts_accounts, id: :uuid do |t|
+      t.references :user, null: false, foreign_key: true, type: :uuid
+      t.string :password_digest
+      t.string :refresh_token_digest
+      t.string :said, null: false
+
+      t.datetime :login_at
+      t.datetime :password_changed_at
+      t.datetime :password_set_at
+
+      t.string :login_invitation, default: ''
+      t.string :password_set_invitation, default: ''
+      t.string :password_change_invitation, default: ''
+
+      t.timestamps
+    end
+  end
+end

data/lib/tasks/with_accounts_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :with_accounts do
+#   # Task goes here
+# end

data/lib/with_accounts/engine.rb

@@ -0,0 +1,10 @@
+module WithAccounts
+  class Engine < ::Rails::Engine
+    isolate_namespace WithAccounts
+    config.generators.api_only = true
+    # config.autoload_paths += %W(#{config.root}/lib/modules)
+    config.generators do |g|
+      g.test_framework :rspec
+    end
+  end
+end

data/lib/with_accounts/errors_helpers.rb

@@ -0,0 +1,54 @@
+module WithAccounts
+  module ErrorsHelpers
+    def error_key
+      self.class.name.demodulize.to_sym
+    end
+
+    def format_errors(errors_hash)
+      raise StandardError unless errors_hash.present? && errors_hash.is_a?(Hash) && errors_hash.keys.size == 1
+
+      errors_key = errors_hash.keys.first
+      errors = errors_hash.values.flatten.first
+
+      errors = errors.respond_to?(:to_h) ? errors.to_h : errors
+
+      case errors
+      when Hash
+        sort_hash_errors(errors, errors_key)
+      when Array
+        sort_array_errors(errors, errors_key)
+      when String
+        sort_string_errors(errors, errors_key)
+      else
+        raise StandardError
+      end
+    end
+
+    private
+
+    def sort_hash_errors(errors, errors_hash_key)
+      errors.each_with_object({}) do |error, hash|
+        key = error.flatten.first
+        hash[:other_errors] ||= { "#{errors_hash_key}": [] }
+        hash[:other_errors][errors_hash_key] << key
+      end
+    end
+
+    def sort_array_errors(errors, errors_hash_key)
+      hash = {}
+      errors.flatten.each do
+        key = _1.split(' ').first
+        hash[:other_errors] ||= { "#{errors_hash_key}": [] }
+        hash[:other_errors][errors_hash_key] << key
+        hash
+      end
+    end
+
+    def sort_string_errors(errors, errors_hash_key)
+      hash = {}
+      hash[:other_errors] ||= { "#{errors_hash_key}": [errors] }
+      hash
+    end
+  end
+end
+

data/lib/with_accounts/version.rb

@@ -0,0 +1,3 @@
+module WithAccounts
+  VERSION = "0.1.1"
+end

data/lib/with_accounts.rb

@@ -0,0 +1,6 @@
+require "with_accounts/version"
+require "with_accounts/engine"
+
+module WithAccounts
+  # Your code goes here...
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: with_accounts
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- zabodaevmm
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-10-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
+email:
+- zabodaevmm@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/controllers/with_accounts/application_controller.rb
+- app/controllers/with_accounts/meaningful_controller.rb
+- app/models/with_accounts/account.rb
+- app/models/with_accounts/application_record.rb
+- app/scenarios/with_accounts/jwts/access_tokens_creating/check_refresh_token.rb
+- app/scenarios/with_accounts/jwts/access_tokens_creating/find_and_check_account.rb
+- app/scenarios/with_accounts/jwts/access_tokens_creating/prepare_access_token_payload.rb
+- app/scenarios/with_accounts/jwts/access_tokens_creating/scenario.rb
+- app/scenarios/with_accounts/jwts/create_token.rb
+- app/scenarios/with_accounts/jwts/refresh_tokens_creating/check_login_invitation.rb
+- app/scenarios/with_accounts/jwts/refresh_tokens_creating/prepare_refresh_token_payload.rb
+- app/scenarios/with_accounts/jwts/refresh_tokens_creating/scenario.rb
+- app/scenarios/with_accounts/jwts/refresh_tokens_creating/update_account.rb
+- app/scenarios/with_accounts/login_invitations_creating/check_params.rb
+- app/scenarios/with_accounts/login_invitations_creating/find_and_check_account.rb
+- app/scenarios/with_accounts/login_invitations_creating/scenario.rb
+- app/scenarios/with_accounts/login_invitations_creating/send_email_to_user.rb
+- app/scenarios/with_accounts/login_invitations_creating/update_account_login_invitation.rb
+- app/scenarios/with_accounts/passwords_creating/check_params.rb
+- app/scenarios/with_accounts/passwords_creating/check_password_set_invitation.rb
+- app/scenarios/with_accounts/passwords_creating/scenario.rb
+- app/scenarios/with_accounts/passwords_creating/update_account.rb
+- config/routes.rb
+- db/migrate/20231004123741_create_with_accounts_accounts.rb
+- lib/tasks/with_accounts_tasks.rake
+- lib/with_accounts.rb
+- lib/with_accounts/engine.rb
+- lib/with_accounts/errors_helpers.rb
+- lib/with_accounts/version.rb
+homepage: https://github.com/zabodaevmm/with_accounts
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/zabodaevmm/with_accounts
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: Accounts logic on demand.
+test_files: []