psdk-cli 0.1.0 → 0.1.1

data/lib/psdk/helpers/plugin_manager/builder.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'digest'
+require_relative '../900 Yuki__VD'
+
+module PluginManager
+  # Class responsible of building plugins
+  class Builder # rubocop:disable Metrics/ClassLength
+    PLUGIN_FILE_EXT = 'psdkplug'
+    SCRIPTS_FOLDER = 'scripts'
+
+    # Create a new plugin builder
+    # @param plugin_name [String] name of the plugin directory
+    # @param in_project [Boolean] whether we are building inside a PSDK project
+    # @param out_dir [String] directory to output the compiled plugin
+    def initialize(plugin_name, in_project: true, out_dir: '.')
+      @name = plugin_name
+      @in_project = in_project
+      @out_dir = out_dir
+    end
+
+    # Start the building process
+    def build # rubocop:disable Metrics/MethodLength
+      puts "--- Starting build for plugin '#{@name}' ---"
+      if @in_project
+        puts '[INFO] Operating inside a PSDK project.'
+      else
+        puts '[INFO] Operating in standalone mode (outside a PSDK project).'
+      end
+
+      project_root = @in_project.is_a?(String) ? @in_project : Dir.pwd
+      out_dir = File.absolute_path(@out_dir)
+
+      Dir.chdir(project_root) do
+        @config = load_plugin_configuration
+        plugin_filename = File.join(out_dir, "#{@config.name}.#{PLUGIN_FILE_EXT}")
+        tmp_filename = "#{plugin_filename}.tmp"
+
+        build_internal(tmp_filename)
+        compute_sha512(tmp_filename)
+        write_config_an_rename_file(tmp_filename, plugin_filename)
+
+        puts "\e[32m[SUCCESS]\e[0m Built #{@config.name} at #{plugin_filename}"
+      end
+    end
+
+    private
+
+    # Return the base directory of the plugin source code
+    def base_dir
+      if @in_project
+        File.join(SCRIPTS_FOLDER, @name)
+      else
+        @name == '.' ? '.' : @name
+      end
+    end
+
+    # Return the directory name used for scripts relative to base_dir
+    def script_src_dir
+      # Inside a project, scripts are often in `scripts/{plugin_name}/scripts/**/*.rb`
+      # Outside, it's `scripts/**/*.rb`
+      # In both cases, the folder is `scripts` relative to base_dir (or `script` according to some docs, we check both or use 'scripts') # rubocop:disable Layout/LineLength
+      return 'scripts'
+    end
+
+    # Internal plugin build process
+    # @param tmp_filename [String] temporary filename of the .psdkplug file (before SHA512 computation)
+    def build_internal(tmp_filename)
+      puts "Creating temporary plugin file: #{tmp_filename}"
+      @yuki_vd = Yuki::VD.new(tmp_filename, :write)
+
+      add_scripts
+      add_files
+      add_testers
+
+      @yuki_vd.close
+    end
+
+    # Function that adds all the scripts for the plugin
+    def add_scripts # rubocop:disable Metrics/MethodLength
+      b_dir = base_dir
+      b_dir_prefix = b_dir == '.' ? '' : "#{b_dir}/"
+
+      search_path = File.join(b_dir, script_src_dir, '**', '*.rb')
+      search_path = search_path.sub(%r{^/}, '') if search_path.start_with?('/')
+
+      scripts = Dir[search_path]
+
+      puts "Found #{scripts.size} ruby scripts to pack."
+      scripts.each do |filename|
+        script = File.read(filename)
+        internal_path = filename.sub(b_dir_prefix, '')
+        puts "  - Packing script: #{filename} -> #{internal_path}"
+        @yuki_vd.write_data(internal_path, script)
+      end
+    end
+
+    # Function that add all the files for the plugin
+    def add_files
+      filenames = (@config.added_files || []).flat_map { |dirspec| Dir[dirspec] }.select { |f| File.file?(f) }
+
+      puts "Found #{filenames.size} resource files to pack."
+      filenames.each do |filename|
+        data = File.binread(filename)
+        puts "  - Packing file: #{filename}"
+        @yuki_vd.write_data(filename, data)
+      end
+    end
+
+    # Function that adds the compatibility test script
+    def add_testers # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+      b_dir = base_dir
+      if @config.psdk_compatibility_script
+        tester_path = File.join(b_dir, @config.psdk_compatibility_script)
+        if File.exist?(tester_path)
+          puts "Adding PSDK compatibility script: #{tester_path}"
+          data = File.read(tester_path)
+          @yuki_vd.write_data("\x01", data)
+        else
+          puts "[WARNING] PSDK compatibility script not found: #{tester_path}"
+        end
+      end
+      return unless @config.additional_compatibility_script
+
+      tester_path = File.join(b_dir, @config.additional_compatibility_script)
+      if File.exist?(tester_path)
+        puts "Adding additional compatibility script: #{tester_path}"
+        data = File.read(tester_path)
+        @yuki_vd.write_data("\x02", data)
+      else
+        puts "[WARNING] Additional compatibility script not found: #{tester_path}"
+      end
+    end
+
+    # Load the plugin configuration
+    # @return [PluginManager::Config]
+    def load_plugin_configuration
+      config_path = File.join(base_dir, 'config.yml')
+      raise "Configuration file not found at #{config_path}" unless File.exist?(config_path)
+
+      puts "Loading configuration from #{config_path}"
+      return YAML.unsafe_load(File.read(config_path))
+    end
+
+    # Compute the SHA512 hash of the temporary psdkplug
+    # @param tmp_filename [String] filename of the temporary psdkplug
+    def compute_sha512(tmp_filename)
+      puts 'Computing SHA512 of the generated package...'
+      filesize = File.binread(tmp_filename, Yuki::VD::POINTER_SIZE).unpack1(Yuki::VD::UNPACK_METHOD) - Yuki::VD::POINTER_SIZE
+      filedata = File.binread(tmp_filename, filesize, Yuki::VD::POINTER_SIZE)
+      @config.sha512 = Digest::SHA512.hexdigest(filedata)
+    end
+
+    # Write the config of the plugin and rename the temporary file to the final plugin filename
+    # @param tmp_filename [String] filename of the temporary psdkplug
+    # @param plugin_filename [String] filename of the final psdkplug
+    def write_config_an_rename_file(tmp_filename, plugin_filename)
+      puts 'Writing final configuration with SHA512 to package...'
+      @yuki_vd = Yuki::VD.new(tmp_filename, :update)
+      @yuki_vd.write_data("\x00", Marshal.dump(@config))
+      @yuki_vd.close
+
+      File.rename(tmp_filename, plugin_filename)
+    end
+  end
+end

data/lib/psdk/helpers/plugin_manager/config.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module PluginManager
+  # Plugin configuration
+  class Config
+    # Get the plugin name
+    # @return [String]
+    attr_accessor :name
+    # Get the plugin authors
+    # @return [Array<String>]
+    attr_accessor :authors
+    # Get the version of the plugin
+    # @return [String]
+    attr_accessor :version
+    # Get the dependecies or incompatibilities of the plugin
+    # @return [Array<Hash>]
+    attr_accessor :deps
+    # Get the script that tests if PSDK is compatible with this plugin
+    # @return [String, nil]
+    attr_accessor :psdk_compatibility_script
+    # Tell if the psdk_compatibility_script should be executed after all plugins has been loaded
+    # @return [Boolean, nil]
+    attr_accessor :retry_psdk_compatibility_after_plugin_load
+    # Get the script that tests if the plugin is compatible with other plugins
+    # @return [String, nil]
+    attr_accessor :additional_compatibility_script
+    # Get all the files added by the plugin (in order to compile the plugin / remove files)
+    # @return [Array<String>]
+    attr_accessor :added_files
+    # Get the SHA512 of the plugin (computed after it got compiled)
+    # @return [String]
+    attr_accessor :sha512
+    # Get the PSDK version the plugin was installed
+    # @return [Integer]
+    attr_accessor :psdk_version
+  end
+end

data/lib/psdk/helpers/plugin_manager/list.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module PluginManager
+  # Module handling the listing of plugins
+  module List
+    # Folder containing scripts
+    SCRIPTS_FOLDER = 'scripts'
+    # File containing plugin information
+    PLUGIN_INFO_FILE = "#{SCRIPTS_FOLDER}/plugins.dat".freeze
+
+    class << self
+      # List all the plugins
+      def list_plugins
+        plugins = load_existing_plugins
+        show_splash(' List of your plugins')
+        if plugins.empty?
+          puts 'No plugins installed.'
+          return
+        end
+
+        plugins.each do |plugin|
+          puts "- \e[34m#{plugin.name}\e[36m v#{plugin.version}\e[0m"
+          puts "  authors: #{plugin.authors.join(', ')}"
+        end
+      end
+
+      private
+
+      # Load the plugins that are already installed
+      # @return [Array<PluginManager::Config>]
+      def load_existing_plugins
+        return File.exist?(PLUGIN_INFO_FILE) ? Marshal.load(File.binread(PLUGIN_INFO_FILE)) : [] # rubocop:disable Security/MarshalLoad
+      rescue StandardError => e
+        puts "Failed to load plugins.dat: #{e.message}"
+        []
+      end
+
+      # Show the plugin manager splash
+      # @param reason [String] reason to show the splash
+      def show_splash(reason = ' Something changed in your plugins! ')
+        sep = ''.center(80, '=')
+        puts "\e[32m#{sep}\e[0m"
+        puts "\e[32m##{' PSDK Plugin Manager v1.0 '.center(78, ' ')}#\e[0m"
+        puts "\e[32m##{reason.ljust(78, ' ')}#\e[0m"
+        puts "\e[32m#{sep}\e[0m"
+      end
+    end
+  end
+end

data/lib/psdk/helpers/plugin_manager.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'plugin_manager/config'
+require_relative 'plugin_manager/list'
+require_relative 'plugin_manager/builder'
+
+# Module handling the plugin commands
+module PluginManager
+  class << self
+    # List all the plugins installed in the current PSDK project
+    def list
+      List.list_plugins
+    end
+
+    # Build a plugin
+    # @param plugin_name [String] name of the plugin to build
+    # @param in_project [Boolean] whether to build using PSDK project structure
+    # @param out_dir [String] directory to output the compiled plugin
+    def build(plugin_name, in_project: true, out_dir: '.')
+      Builder.new(plugin_name, in_project: in_project, out_dir: out_dir).build
+    end
+  end
+end

data/lib/psdk/helpers/psdk.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+require_relative '../cli/configuration'
+require 'fileutils'
+
+module Psdk
+  module Cli
+    # Module holding all the utility to interact with PSDK repository
+    module PSDK # rubocop:disable Metrics/ModuleLength
+      # Default URL to the PSDK repository
+      MAIN_REPOSITORY_URL = 'https://gitlab.com/pokemonsdk/pokemonsdk.git'
+
+      module_function
+
+      # Ensure the PSDK module is cloned
+      def ensure_repository_cloned
+        return if Dir.exist?(File.join(repository_path, '.git'))
+
+        res = system('git', 'clone', MAIN_REPOSITORY_URL, chdir: Configuration::PATH)
+        return if res
+
+        puts "[Error] Failed to setup pokemonsdk repository in `#{Configuration::PATH}`"
+        exit(1)
+      end
+
+      # Get the repository path
+      # @return [String]
+      def repository_path
+        return File.join(Configuration::PATH, 'pokemonsdk')
+      end
+
+      # Make the project use an official PSDK release
+      # @param version [String] release identifier (e.g., "26.58")
+      def use_version(version)
+        switch_project_repository("official release #{version}") do |path|
+          fetch_repository(path)
+          commit = run_git(path, 'log', '--format=%H', '--extended-regexp',
+                           "--grep=^Release #{Regexp.escape(version)}$", '--max-count=1', 'origin/release')
+          raise "PSDK release #{version} was not found" if commit.empty?
+
+          run_git(path, 'checkout', '--detach', commit)
+        end
+      end
+
+      # Make the project use a specific PSDK commit
+      # @param commit [String] commit identifier (e.g., "deadcafe")
+      def use_commit(commit)
+        switch_project_repository("commit #{commit}") do |path|
+          fetch_repository(path)
+          resolved_commit = run_git(path, 'rev-parse', '--verify', '--end-of-options', "#{commit}^{commit}")
+          run_git(path, 'checkout', '--detach', resolved_commit)
+        end
+      end
+
+      # Make the project use the head of a GitLab merge request
+      # @param id [String] merge request ID (e.g., "123")
+      def use_mr(id)
+        switch_project_repository("merge request !#{id}") do |path|
+          ref = "refs/remotes/origin/merge-requests/#{id}"
+          run_git(path, 'fetch', 'origin', "+refs/merge-requests/#{id}/head:#{ref}")
+          run_git(path, 'checkout', '-B', "mr-#{id}", ref)
+        end
+      end
+
+      # Make the project use the latest development commit
+      def use_latest
+        switch_project_repository('latest development commit') do |path|
+          fetch_repository(path)
+          run_git(path, 'checkout', '-B', 'development', 'origin/development')
+        end
+      end
+
+      # Unuse the local pokemonsdk folder (meaning we want the project to fallback on Pokémon Studio's PSDK)
+      # @param delete [Boolean] if the folder should be deleted
+      def unuse_local_pokemonsdk(delete:)
+        project_path = Configuration.project_path
+        psdk_path = File.join(project_path, 'pokemonsdk')
+        return unless Dir.exist?(psdk_path)
+
+        if git_project?(project_path) && submodule?(project_path)
+          remove_submodule(project_path, delete)
+        else
+          handle_non_submodule_folder(psdk_path, delete)
+        end
+      ensure
+        puts "Successfully set project to use Pokémon Studio's PSDK version"
+      end
+
+      # Handle the pokemonsdk folder when it's not a submodule
+      # @param psdk_path [String] the path to the pokemonsdk folder
+      # @param delete [Boolean] if the folder should be deleted
+      def handle_non_submodule_folder(psdk_path, delete)
+        if delete
+          FileUtils.rm_rf(psdk_path)
+        else
+          rename_pokemonsdk_folder(psdk_path)
+        end
+      end
+
+      # Check if the project is a git project
+      # @param project_path [String] the path to the project
+      # @return [Boolean]
+      def git_project?(project_path)
+        return File.exist?(File.join(project_path, '.git'))
+      end
+
+      # Check if the project is a submodule
+      # @param project_path [String] the path to the project
+      # @return [Boolean]
+      def submodule?(project_path)
+        return system('git', 'submodule', 'status', 'pokemonsdk', chdir: project_path, out: File::NULL, err: File::NULL)
+      end
+
+      # Remove the submodule
+      # @param project_path [String] the path to the project
+      # @param delete [Boolean] if the folder should be deleted
+      def remove_submodule(project_path, delete)
+        return show_remove_submodule_delete_error unless delete
+
+        r = system('git', 'submodule', 'deinit', '-f', 'pokemonsdk', chdir: project_path, out: File::NULL, err: File::NULL)
+        raise 'Failed to deinit pokemonsdk submodule' unless r
+
+        r = system('git', 'rm', '-f', 'pokemonsdk', chdir: project_path, out: File::NULL, err: File::NULL)
+        raise 'Failed to remove pokemonsdk submodule' unless r
+
+        FileUtils.rm_rf(File.join(project_path, '.git', 'modules', 'pokemonsdk'))
+        puts 'Successfully removed the submodule'
+      rescue StandardError => e
+        puts "[Error] Failed to remove the submodule (#{e.message})"
+        exit(1)
+      end
+
+      # Show the error message when attempting to delete the pokemonsdk submodule
+      def show_remove_submodule_delete_error
+        puts "[Error] Cannot use Studio's PSDK version if the project has a submodule."
+        puts 'Please follow this guide to remove the submodule: https://stackoverflow.com/a/1260982'
+        exit(1)
+      end
+
+      # Rename the pokemonsdk folder
+      # @param psdk_path [String] the path to the pokemonsdk folder
+      def rename_pokemonsdk_folder(psdk_path)
+        new_path = "#{psdk_path}_old"
+        if File.exist?(new_path)
+          puts "[Error] Folder `#{new_path}` already exists. Please remove it manually."
+          exit(1)
+        else
+          File.rename(psdk_path, new_path)
+        end
+      end
+
+      # Run a repository switch: resolve the project's pokemonsdk path, apply the given block,
+      # then refresh submodules and report the active target
+      # @param target [String] human-readable description of the switch target, used in the confirmation message
+      # @yieldparam path [String] path to the project's pokemonsdk repository
+      def switch_project_repository(target)
+        path = ensure_project_repository
+        yield(path)
+        run_git(path, 'submodule', 'update', '--init', '--recursive')
+        show_active_target(path, target)
+      rescue StandardError => e
+        show_switch_error(e)
+      end
+
+      # Ensure the project's pokemonsdk repository exists, cloning it if necessary
+      # @return [String] path to the project's pokemonsdk repository
+      def ensure_project_repository
+        path = File.join(Configuration.project_path, 'pokemonsdk')
+        return path if File.exist?(File.join(path, '.git'))
+
+        raise "#{path} exists but is not a Git repository" if Dir.exist?(path)
+
+        success = system('git', 'clone', MAIN_REPOSITORY_URL, path)
+        raise "Failed to clone pokemonsdk into `#{path}`" unless success
+
+        return path
+      end
+
+      # Fetch the latest refs from origin
+      # @param path [String] path to the repository
+      def fetch_repository(path)
+        run_git(path, 'fetch', 'origin')
+      end
+
+      # Run a git command in the given repository and return its output
+      # @param path [String] path to the repository
+      # @param arguments [Array<String>] git subcommand and its arguments
+      # @return [String] the stripped stdout of the command
+      def run_git(path, *arguments)
+        output = IO.popen(['git', *arguments], chdir: path, &:read)
+        return output.strip if $?.success? # rubocop:disable Style/SpecialGlobalVars
+
+        raise "git #{arguments.join(' ')} failed"
+      end
+
+      # Show the confirmation message for the currently active PSDK target
+      # @param path [String] path to the repository
+      # @param target [String] human-readable description of the active target
+      def show_active_target(path, target)
+        commit = run_git(path, 'rev-parse', '--short', 'HEAD')
+        version = File.read(File.join(path, 'version.txt')).to_i
+        version_string = [version].pack('I>').unpack('C*').join('.').gsub(/^(0\.)+/, '')
+        puts "Active PSDK: #{target} (version #{version_string}, commit #{commit})"
+      end
+
+      # Show the error message when a PSDK switch operation fails
+      # @param error [StandardError] the error that was raised
+      def show_switch_error(error)
+        puts "[Error] Failed to switch PSDK: #{error.message}"
+        exit(1)
+      end
+    end
+  end
+end

data/lib/psdk/helpers/studio.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative '../cli/configuration'
+
+module Psdk
+  module Cli
+    # Module holding all the logic about the Pokémon Studio
+    module Studio
+      module_function
+
+      # Find and Save Pokemon studio path
+      # @param type [:global | :local] where to save the located studio path
+      def find_and_save_path(type)
+        locations = common_studio_location.select { |l| Dir.exist?(l) }
+        binaries_locations = psdk_binaries_locations
+        studio_path = locations.find { |l| binaries_locations.any? { |b| Dir.exist?(File.join(l, b)) } }
+        unless studio_path
+          puts '[Error] failed to locate Pokemon Studio, please set it up manually'
+          exit(1)
+        end
+
+        puts "Located Pokemon Studio in `#{studio_path}`"
+        Configuration.get(type).studio_path = studio_path
+        Configuration.save
+      end
+
+      # Get the PSDK binary path based on Studio path
+      # @param path [String]
+      # @return [String | nil]
+      def psdk_binaries_path(path)
+        valid_path = psdk_binaries_locations.find { |l| Dir.exist?(File.join(path, l)) }
+        return nil unless valid_path
+
+        return File.join(path, valid_path)
+      end
+
+      # Get all the common Pokemon Studio location
+      # @return [Array<String>]
+      def common_studio_location
+        volumes = Dir['/Volumes/**'] + Dir['/dev/sd*']
+        return [
+          '/Applications/PokemonStudio.app',
+          *(ENV['AppData'] ? studio_app_data_location : nil),
+          *volumes.map { |v| File.join(v, 'projects', 'PokemonStudio') },
+          'C:/Projects/PokemonStudio'
+        ]
+      end
+
+      # Get all the psdk-binaries common location in Studio
+      # @return [Array<String>]
+      def psdk_binaries_locations
+        return [
+          'psdk-binaries',
+          'Contents/Resources/psdk-binaries',
+          'resources/psdk-binaries'
+        ]
+      end
+
+      # Get the location of Studio in appdata
+      # @return [String]
+      def studio_app_data_location
+        return File.join(ENV.fetch('AppData', '.'), '../Local/Programs/pokemon-studio')
+      end
+    end
+  end
+end

data/lib/psdk/helpers/version.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative '../cli/configuration'
+require_relative 'studio'
+require_relative 'psdk'
+
+module Psdk
+  module Cli
+    # Module holding all the logic about the version command
+    module Version
+      module_function
+
+      # Run the version command
+      # @param no_psdk_version [Boolean] do not show PSDK version if true
+      def run(no_psdk_version)
+        puts "psdk-cli v#{VERSION}"
+        return if no_psdk_version
+
+        print "Searching for PSDK version...\r"
+        search_and_show_psdk_version
+      end
+
+      # Search and show the PSDK version
+      def search_and_show_psdk_version
+        search_and_show_global_psdk_version
+        search_and_show_local_psdk_version
+      end
+
+      # Search and show the global PSDK version
+      def search_and_show_global_psdk_version
+        PSDK.ensure_repository_cloned
+        psdk_path = PSDK.repository_path
+        show_global_psdk_version(psdk_path)
+        git_data = load_git_data(psdk_path)
+        puts "Global PSDK git Target: #{git_data}"
+      end
+
+      # Show the global PSDK version
+      # @param psdk_path [String] Path to the PSDK repository
+      def show_global_psdk_version(psdk_path)
+        version_string = version_to_string(load_version_integer(psdk_path))
+        puts "Global PSDK version: #{version_string}       "
+      end
+
+      # Search and show the local PSDK version
+      def search_and_show_local_psdk_version
+        Configuration.get(:local)
+        return unless Configuration.project_path
+
+        psdk_path = File.join(Configuration.project_path, 'pokemonsdk')
+        return show_no_local_psdk_version unless Dir.exist?(psdk_path)
+
+        version_string = version_to_string(load_version_integer(psdk_path))
+        puts "Project PSDK version: #{version_string}"
+        git_data = load_git_data(psdk_path)
+        puts "Project's PSDK git target: #{git_data}" unless git_data.empty?
+      end
+
+      # Show that there's no local PSDK version
+      def show_no_local_psdk_version
+        Studio.find_and_save_path(:local) if Configuration.get(:local).studio_path.empty?
+        psdk_binaries_path = Studio.psdk_binaries_path(Configuration.get(:local).studio_path)
+        unless psdk_binaries_path
+          puts 'Project PSDK Version: Cannot locate Pokémon Studio or local repository...'
+          exit(1)
+        end
+
+        version_string = version_to_string(load_version_integer(File.join(psdk_binaries_path, 'pokemonsdk')))
+        puts "Project PSDK Version: #{version_string} (Pokémon Studio)"
+      end
+
+      # Load the Git data if any
+      # @param path [String] path to the PSDK installation
+      # @return [String]
+      def load_git_data(path)
+        Dir.chdir(path) do
+          return '' unless Dir.exist?('.git') || Dir.exist?('../.git')
+
+          commit = `git log --oneline -n 1`.chomp
+          branch = `git branch --show-current`.chomp
+          return "[#{branch}] #{commit}" unless branch.empty?
+
+          return "[!detached] #{commit}"
+        end
+      end
+
+      # Convert a version integer to a version string
+      # @param version [Integer]
+      # @return [String]
+      def version_to_string(version)
+        return [version].pack('I>').unpack('C*').join('.').gsub(/^(0\.)+/, '')
+      end
+
+      # Get the version integer from a path
+      # @param path [String] path where PSDK repository is
+      # @return [Integer]
+      def load_version_integer(path)
+        filename = File.join(path, 'version.txt')
+        return 0 unless File.exist?(filename)
+
+        return File.read(filename).to_i
+      end
+    end
+  end
+end