tokite 4.0.0 → 5.0.0

data/vendor/bundle/ruby/3.4.0/gems/railties-8.1.2/lib/rails/generators/test_unit/authentication/templates/test/controllers/passwords_controller_test.rb.tt

@@ -0,0 +1,67 @@
+require "test_helper"
+
+class PasswordsControllerTest < ActionDispatch::IntegrationTest
+  setup { @user = User.take }
+
+  test "new" do
+    get new_password_path
+    assert_response :success
+  end
+
+  test "create" do
+    post passwords_path, params: { email_address: @user.email_address }
+    assert_enqueued_email_with PasswordsMailer, :reset, args: [ @user ]
+    assert_redirected_to new_session_path
+
+    follow_redirect!
+    assert_notice "reset instructions sent"
+  end
+
+  test "create for an unknown user redirects but sends no mail" do
+    post passwords_path, params: { email_address: "missing-user@example.com" }
+    assert_enqueued_emails 0
+    assert_redirected_to new_session_path
+
+    follow_redirect!
+    assert_notice "reset instructions sent"
+  end
+
+  test "edit" do
+    get edit_password_path(@user.password_reset_token)
+    assert_response :success
+  end
+
+  test "edit with invalid password reset token" do
+    get edit_password_path("invalid token")
+    assert_redirected_to new_password_path
+
+    follow_redirect!
+    assert_notice "reset link is invalid"
+  end
+
+  test "update" do
+    assert_changes -> { @user.reload.password_digest } do
+      put password_path(@user.password_reset_token), params: { password: "new", password_confirmation: "new" }
+      assert_redirected_to new_session_path
+    end
+
+    follow_redirect!
+    assert_notice "Password has been reset"
+  end
+
+  test "update with non matching passwords" do
+    token = @user.password_reset_token
+    assert_no_changes -> { @user.reload.password_digest } do
+      put password_path(token), params: { password: "no", password_confirmation: "match" }
+      assert_redirected_to edit_password_path(token)
+    end
+
+    follow_redirect!
+    assert_notice "Passwords did not match"
+  end
+
+  private
+    def assert_notice(text)
+      assert_select "div", /#{text}/
+    end
+end

data/vendor/bundle/ruby/3.4.0/gems/railties-8.1.2/lib/rails/generators/test_unit/authentication/templates/test/controllers/sessions_controller_test.rb

@@ -0,0 +1,33 @@
+require "test_helper"
+
+class SessionsControllerTest < ActionDispatch::IntegrationTest
+  setup { @user = User.take }
+
+  test "new" do
+    get new_session_path
+    assert_response :success
+  end
+
+  test "create with valid credentials" do
+    post session_path, params: { email_address: @user.email_address, password: "password" }
+
+    assert_redirected_to root_path
+    assert cookies[:session_id]
+  end
+
+  test "create with invalid credentials" do
+    post session_path, params: { email_address: @user.email_address, password: "wrong" }
+
+    assert_redirected_to new_session_path
+    assert_nil cookies[:session_id]
+  end
+
+  test "destroy" do
+    sign_in_as(User.take)
+
+    delete session_path
+
+    assert_redirected_to new_session_path
+    assert_empty cookies[:session_id]
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/railties-8.1.2/lib/rails/generators/test_unit/authentication/templates/test/models/user_test.rb.tt

@@ -0,0 +1,8 @@
+require "test_helper"
+
+class UserTest < ActiveSupport::TestCase
+  test "downcases and strips email_address" do
+    user = User.new(email_address: " DOWNCASED@EXAMPLE.COM ")
+    assert_equal("downcased@example.com", user.email_address)
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/railties-8.1.2/lib/rails/generators/test_unit/authentication/templates/test/test_helpers/session_test_helper.rb.tt

@@ -0,0 +1,19 @@
+module SessionTestHelper
+  def sign_in_as(user)
+    Current.session = user.sessions.create!
+
+    ActionDispatch::TestRequest.create.cookie_jar.tap do |cookie_jar|
+      cookie_jar.signed[:session_id] = Current.session.id
+      cookies["session_id"] = cookie_jar[:session_id]
+    end
+  end
+
+  def sign_out
+    Current.session&.destroy!
+    cookies.delete("session_id")
+  end
+end
+
+ActiveSupport.on_load(:action_dispatch_integration_test) do
+  include SessionTestHelper
+end

data/vendor/bundle/ruby/3.4.0/gems/railties-8.1.2/lib/rails/generators/test_unit/model/templates/fixtures.yml.tt

@@ -0,0 +1,29 @@
+# Read about fixtures at https://api.rubyonrails.org/classes/ActiveRecord/FixtureSet.html
+<% unless attributes.empty? -%>
+<% %w(one two).each do |name| %>
+<%= name %>:
+<% attributes.each do |attribute| -%>
+  <%- if attribute.password_digest? -%>
+  password_digest: <%= BCrypt::Password.create("secret") %>  # Generated with BCrypt::Password.create("secret")
+  <%- elsif attribute.reference? -%>
+  <%= yaml_key_value(attribute.column_name.delete_suffix("_id"), attribute.default || name) %>
+  <%- elsif !attribute.virtual? -%>
+  <%= yaml_key_value(attribute.column_name, attribute.default) %>
+  <%- end -%>
+  <%- if attribute.polymorphic? -%>
+  <%= yaml_key_value("#{attribute.name}_type", attribute.human_name) %>
+  <%- end -%>
+<% end -%>
+<% end -%>
+<% else -%>
+
+# This model initially had no columns defined. If you add columns to the
+# model remove the "{}" from the fixture names and add the columns immediately
+# below each fixture, per the syntax in the comments below
+#
+one: {}
+# column: value
+#
+two: {}
+# column: value
+<% end -%>

data/vendor/bundle/ruby/3.4.0/gems/railties-8.1.2/lib/rails/generators/test_unit/scaffold/scaffold_generator.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "rails/generators/test_unit"
+require "rails/generators/resource_helpers"
+
+module TestUnit # :nodoc:
+  module Generators # :nodoc:
+    class ScaffoldGenerator < Base # :nodoc:
+      include Rails::Generators::ResourceHelpers
+
+      check_class_collision suffix: "ControllerTest"
+
+      class_option :api, type: :boolean,
+                         desc: "Generate API functional tests"
+
+      class_option :system_tests, type: :string,
+                         desc: "Generate system test files (set to 'true' to enable)"
+
+      argument :attributes, type: :array, default: [], banner: "field:type field:type"
+
+      def create_test_files
+        template_file = options.api? ? "api_functional_test.rb" : "functional_test.rb"
+        template template_file,
+                 File.join("test/controllers", controller_class_path, "#{controller_file_name}_controller_test.rb")
+
+        # Generate system tests if this isn't an API only app and the system
+        # tests option is true
+        if !options.api? && options[:system_tests] == "true"
+          if !File.exist?(File.join("test/application_system_test_case.rb"))
+            template "application_system_test_case.rb", File.join("test", "application_system_test_case.rb")
+          end
+
+          template "system_test.rb", File.join("test/system", class_path, "#{file_name.pluralize}_test.rb")
+        end
+      end
+
+      def fixture_name
+        @fixture_name ||=
+          if mountable_engine?
+            (namespace_dirs + [table_name]).join("_")
+          else
+            table_name
+          end
+      end
+
+      private
+        def attributes_string
+          if attributes_hash.empty?
+            "{}"
+          else
+            "{ #{attributes_hash.map { |k, v| "#{k}: #{v}" }.join(", ")} }"
+          end
+        end
+
+        def attributes_hash
+          return {} if attributes_names.empty?
+
+          attributes_names.filter_map do |name|
+            if %w(password password_confirmation).include?(name) && attributes.any?(&:password_digest?)
+              ["#{name}", '"secret"']
+            elsif !virtual?(name)
+              ["#{name}", "@#{singular_table_name}.#{name}"]
+            end
+          end.sort.to_h
+        end
+
+        def boolean?(name)
+          attribute = attributes.find { |attr| attr.name == name }
+          attribute&.type == :boolean
+        end
+
+        def virtual?(name)
+          attribute = attributes.find { |attr| attr.name == name }
+          attribute&.virtual?
+        end
+
+        def datetime?(name)
+          attribute = attributes.find { |attr| attr.name == name }
+          attribute&.type == :datetime
+        end
+
+        def time?(name)
+          attribute = attributes.find { |attr| attr.name == name }
+          attribute&.type == :time
+        end
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/railties-8.1.2/lib/rails/generators/test_unit/system/templates/application_system_test_case.rb.tt

@@ -0,0 +1,5 @@
+require "test_helper"
+
+class ApplicationSystemTestCase < ActionDispatch::SystemTestCase
+  driven_by :selenium, using: :headless_chrome, screen_size: [ 1400, 1400 ]
+end

data/vendor/bundle/ruby/3.4.0/gems/railties-8.1.2/lib/rails/generators/testing/behavior.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/reverse_merge"
+require "active_support/core_ext/kernel/reporting"
+require "active_support/testing/stream"
+require "rails/generators"
+
+module Rails
+  module Generators
+    module Testing
+      module Behavior
+        extend ActiveSupport::Concern
+        include ActiveSupport::Testing::Stream
+
+        included do
+          # Generators frequently change the current path using +FileUtils.cd+.
+          # So we need to store the path at file load and revert back to it after each test.
+          class_attribute :current_path, default: File.expand_path(Dir.pwd)
+          class_attribute :default_arguments, default: []
+          class_attribute :destination_root
+          class_attribute :generator_class
+        end
+
+        module ClassMethods
+          # Sets which generator should be tested:
+          #
+          #   tests AppGenerator
+          def tests(klass)
+            self.generator_class = klass
+          end
+
+          # Sets default arguments on generator invocation. This can be overwritten when
+          # invoking it.
+          #
+          #   arguments %w(app_name --skip-active-record)
+          def arguments(array)
+            self.default_arguments = array
+          end
+
+          # Sets the destination of generator files:
+          #
+          #   destination File.expand_path("../tmp", __dir__)
+          def destination(path)
+            self.destination_root = path
+          end
+        end
+
+        # Runs the generator configured for this class. The first argument is an array like
+        # command line arguments:
+        #
+        #   class AppGeneratorTest < Rails::Generators::TestCase
+        #     tests AppGenerator
+        #     destination File.expand_path("../tmp", __dir__)
+        #     setup :prepare_destination
+        #
+        #     test "database.yml is not created when skipping Active Record" do
+        #       run_generator %w(myapp --skip-active-record)
+        #       assert_no_file "config/database.yml"
+        #     end
+        #   end
+        #
+        # You can provide a configuration hash as second argument. This method returns the output
+        # printed by the generator.
+        def run_generator(args = default_arguments, config = {})
+          args += ["--skip-bundle"] unless args.include?("--no-skip-bundle") || args.include?("--dev")
+          args += ["--skip-bootsnap"] unless args.include?("--no-skip-bootsnap") || args.include?("--skip-bootsnap")
+
+          if ENV["RAILS_LOG_TO_STDOUT"] == "true"
+            generator_class.start(args, config.reverse_merge(destination_root: destination_root))
+          else
+            capture(:stdout) do
+              generator_class.start(args, config.reverse_merge(destination_root: destination_root))
+            end
+          end
+        end
+
+        # Instantiate the generator.
+        def generator(args = default_arguments, options = {}, config = {})
+          @generator ||= generator_class.new(args, options, config.reverse_merge(destination_root: destination_root))
+        end
+
+        # Create a Rails::Generators::GeneratedAttribute by supplying the
+        # attribute type and, optionally, the attribute name:
+        #
+        #   create_generated_attribute(:string, "name")
+        def create_generated_attribute(attribute_type, name = "test", index = nil)
+          Rails::Generators::GeneratedAttribute.parse([name, attribute_type, index].compact.join(":"))
+        end
+
+        private
+          def destination_root_is_set?
+            raise "You need to configure your Rails::Generators::TestCase destination root." unless destination_root
+          end
+
+          def ensure_current_path
+            cd current_path
+          end
+
+          # Clears all files and directories in destination.
+          def prepare_destination # :doc:
+            rm_rf(destination_root)
+            mkdir_p(destination_root)
+          end
+
+          def migration_file_name(relative)
+            absolute = File.expand_path(relative, destination_root)
+            dirname, file_name = File.dirname(absolute), File.basename(absolute).delete_suffix(".rb")
+            Dir.glob("#{dirname}/[0-9]*_*.rb").grep(/\d+_#{file_name}.rb$/).first
+          end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/railties-8.1.2/lib/rails/generators.rb

@@ -0,0 +1,330 @@
+# frozen_string_literal: true
+
+require "thor/group"
+require "rails/command"
+
+require "active_support/core_ext/array/extract_options"
+require "active_support/core_ext/enumerable"
+require "active_support/core_ext/hash/deep_merge"
+require "active_support/core_ext/module/attribute_accessors"
+require "active_support/core_ext/string/indent"
+require "active_support/core_ext/string/inflections"
+
+module Rails
+  module Generators
+    include Rails::Command::Behavior
+
+    autoload :Actions,         "rails/generators/actions"
+    autoload :ActiveModel,     "rails/generators/active_model"
+    autoload :Base,            "rails/generators/base"
+    autoload :Migration,       "rails/generators/migration"
+    autoload :Database,        "rails/generators/database"
+    autoload :AppName,         "rails/generators/app_name"
+    autoload :NamedBase,       "rails/generators/named_base"
+    autoload :ResourceHelpers, "rails/generators/resource_helpers"
+    autoload :TestCase,        "rails/generators/test_case"
+
+    mattr_accessor :namespace
+
+    DEFAULT_ALIASES = {
+      rails: {
+        actions: "-a",
+        orm: "-o",
+        javascripts: ["-j", "--js"],
+        resource_controller: "-c",
+        scaffold_controller: "-c",
+        stylesheets: "-y",
+        template_engine: "-e",
+        test_framework: "-t"
+      },
+
+      test_unit: {
+        fixture_replacement: "-r",
+      }
+    }
+
+    DEFAULT_OPTIONS = {
+      rails: {
+        api: false,
+        assets: true,
+        force_plural: false,
+        helper: true,
+        integration_tool: nil,
+        orm: false,
+        resource_controller: :controller,
+        resource_route: true,
+        scaffold_controller: :scaffold_controller,
+        system_tests: nil,
+        test_framework: nil,
+        template_engine: :erb
+      }
+    }
+
+    # We need to store the RAILS_DEV_PATH in a constant, otherwise the path
+    # can change when we FileUtils.cd.
+    RAILS_DEV_PATH = File.expand_path("../../..", __dir__) # :nodoc:
+
+    class << self
+      def configure!(config) # :nodoc:
+        api_only! if config.api_only
+        no_color! unless config.colorize_logging
+        aliases.deep_merge! config.aliases
+        options.deep_merge! config.options
+        fallbacks.merge! config.fallbacks
+        templates_path.concat config.templates
+        templates_path.uniq!
+        hide_namespaces(*config.hidden_namespaces)
+        after_generate_callbacks.replace config.after_generate_callbacks
+      end
+
+      def templates_path # :nodoc:
+        @templates_path ||= []
+      end
+
+      def aliases # :nodoc:
+        @aliases ||= DEFAULT_ALIASES.dup
+      end
+
+      def options # :nodoc:
+        @options ||= DEFAULT_OPTIONS.dup
+      end
+
+      def after_generate_callbacks # :nodoc:
+        @after_generate_callbacks ||= []
+      end
+
+      # Hold configured generators fallbacks. If a plugin developer wants a
+      # generator group to fall back to another group in case of missing generators,
+      # they can add a fallback.
+      #
+      # For example, shoulda is considered a +test_framework+ and is an extension
+      # of +test_unit+. However, most part of shoulda generators are similar to
+      # +test_unit+ ones.
+      #
+      # Shoulda then can tell generators to search for +test_unit+ generators when
+      # some of them are not available by adding a fallback:
+      #
+      #   Rails::Generators.fallbacks[:shoulda] = :test_unit
+      def fallbacks
+        @fallbacks ||= {}
+      end
+
+      # Configure generators for API only applications. It basically hides
+      # everything that is usually browser related, such as assets and session
+      # migration generators, and completely disable helpers and assets
+      # so generators such as scaffold won't create them.
+      def api_only!
+        hide_namespaces "assets", "helper", "css", "js"
+
+        options[:rails].merge!(
+          api: true,
+          assets: false,
+          helper: false,
+          template_engine: nil
+        )
+
+        options[:mailer] ||= {}
+        options[:mailer][:template_engine] ||= :erb
+      end
+
+      # Returns an array of generator namespaces that are hidden.
+      # Generator namespaces may be hidden for a variety of reasons.
+      # Some are aliased such as "rails:migration" and can be
+      # invoked with the shorter "migration".
+      def hidden_namespaces
+        @hidden_namespaces ||= begin
+          orm      = options[:rails][:orm]
+          test     = options[:rails][:test_framework]
+          template = options[:rails][:template_engine]
+
+          [
+            "rails",
+            "resource_route",
+            "#{orm}:migration",
+            "#{orm}:model",
+            "#{test}:controller",
+            "#{test}:helper",
+            "#{test}:integration",
+            "#{test}:system",
+            "#{test}:mailer",
+            "#{test}:model",
+            "#{test}:scaffold",
+            "#{test}:view",
+            "#{test}:job",
+            "#{template}:controller",
+            "#{template}:scaffold",
+            "#{template}:mailer",
+            "action_text:install",
+            "action_mailbox:install",
+            "devcontainer"
+          ].tap do |h|
+            h << "test_unit" if test.to_s != "test_unit"
+          end
+        end
+      end
+
+      def hide_namespaces(*namespaces)
+        hidden_namespaces.concat(namespaces)
+      end
+      alias hide_namespace hide_namespaces
+
+      # Show help message with available generators.
+      def help(command = "generate")
+        puts "Usage:"
+        puts "  bin/rails #{command} GENERATOR [args] [options]"
+        puts
+        puts "General options:"
+        puts "  -h, [--help]     # Print generator's options and usage"
+        puts "  -p, [--pretend]  # Run but do not make any changes"
+        puts "  -f, [--force]    # Overwrite files that already exist"
+        puts "  -s, [--skip]     # Skip files that already exist"
+        puts "  -q, [--quiet]    # Suppress status output"
+        puts
+        puts "Please choose a generator below."
+        puts
+
+        print_generators
+      end
+
+      def public_namespaces
+        lookup!
+        subclasses.map(&:namespace)
+      end
+
+      def print_generators
+        sorted_groups.each { |b, n| print_list(b, n) }
+      end
+
+      def sorted_groups
+        namespaces = public_namespaces
+        namespaces.sort!
+
+        groups = Hash.new { |h, k| h[k] = [] }
+        namespaces.each do |namespace|
+          base = namespace.split(":").first
+          groups[base] << namespace
+        end
+
+        rails = groups.delete("rails")
+        rails.map! { |n| n.delete_prefix("rails:") }
+        rails.delete("app")
+        rails.delete("plugin")
+        rails.delete("encrypted_file")
+        rails.delete("encryption_key_file")
+        rails.delete("master_key")
+        rails.delete("credentials")
+        rails.delete("db:system:change")
+
+        hidden_namespaces.each { |n| groups.delete(n.to_s) }
+
+        [[ "rails", rails ]] + groups.sort.to_a
+      end
+
+      # Rails finds namespaces similar to Thor, it only adds one rule:
+      #
+      # Generators names must end with "_generator.rb". This is required because Rails
+      # looks in load paths and loads the generator just before it's going to be used.
+      #
+      #   find_by_namespace :webrat, :rails, :integration
+      #
+      # Will search for the following generators:
+      #
+      #   "rails:webrat", "webrat:integration", "webrat"
+      #
+      # Notice that "rails:generators:webrat" could be loaded as well, what
+      # Rails looks for is the first and last parts of the namespace.
+      def find_by_namespace(name, base = nil, context = nil) # :nodoc:
+        lookups = []
+        lookups << "#{base}:#{name}"    if base
+        lookups << "#{name}:#{context}" if context
+
+        unless base || context
+          unless name.to_s.include?(?:)
+            lookups << "#{name}:#{name}"
+            lookups << "rails:#{name}"
+          end
+          lookups << "#{name}"
+        end
+
+        lookup(lookups)
+
+        namespaces = subclasses.index_by(&:namespace)
+        lookups.each do |namespace|
+          klass = namespaces[namespace]
+          return klass if klass
+        end
+
+        invoke_fallbacks_for(name, base) || invoke_fallbacks_for(context, name)
+      end
+
+      # Receives a namespace, arguments, and the behavior to invoke the generator.
+      # It's used as the default entry point for generate, destroy, and update
+      # commands.
+      def invoke(namespace, args = ARGV, config = {})
+        names = namespace.to_s.split(":")
+        if klass = find_by_namespace(names.pop, names.any? && names.join(":"))
+          args << "--help" if args.empty? && klass.arguments.any?(&:required?)
+          klass.start(args, config)
+          run_after_generate_callback if config[:behavior] == :invoke
+        else
+          options = sorted_groups.flat_map(&:last)
+          error = Command::CorrectableNameError.new("Could not find generator '#{namespace}'.", namespace, options)
+
+          puts <<~MSG
+            #{error.detailed_message}
+            Run `bin/rails generate --help` for more options.
+          MSG
+          exit 1
+        end
+      end
+
+      def add_generated_file(file) # :nodoc:
+        (@@generated_files ||= []) << file
+        file
+      end
+
+      private
+        def print_list(base, namespaces) # :doc:
+          namespaces = namespaces.reject { |n| hidden_namespaces.include?(n) }
+          super
+        end
+
+        # Try fallbacks for the given base.
+        def invoke_fallbacks_for(name, base)
+          return nil unless base && fallbacks[base.to_sym]
+          invoked_fallbacks = []
+
+          Array(fallbacks[base.to_sym]).each do |fallback|
+            next if invoked_fallbacks.include?(fallback)
+            invoked_fallbacks << fallback
+
+            klass = find_by_namespace(name, fallback)
+            return klass if klass
+          end
+
+          nil
+        end
+
+        def command_type # :doc:
+          @command_type ||= "generator"
+        end
+
+        def lookup_paths # :doc:
+          @lookup_paths ||= %w( rails/generators generators )
+        end
+
+        def file_lookup_paths # :doc:
+          @file_lookup_paths ||= [ "{#{lookup_paths.join(',')}}", "**", "*_generator.rb" ]
+        end
+
+        def run_after_generate_callback
+          if defined?(@@generated_files) && !@@generated_files.empty?
+            after_generate_callbacks.each do |callback|
+              callback.call(@@generated_files)
+            end
+            @@generated_files = []
+          end
+        end
+    end
+  end
+end