matrix_sdk 2.3.0 → 2.6.0

data/lib/matrix_sdk/protocols/msc.rb

@@ -60,7 +60,9 @@ module MatrixSdk::Protocols::MSC
     # rubocop:disable Metrics/BlockLength
     thread = Thread.new(cancellation_token) do |ctx|
       print_http(req)
+      @http_lock&.lock
       http.request req do |response|
+        @http_lock&.unlock
         break unless ctx[:run]
 
         print_http(response, body: false)
@@ -134,8 +136,11 @@ module MatrixSdk::Protocols::MSC
             break
           end
         end
+
         break unless ctx[:run]
       end
+    ensure
+      @http_lock.unlock if @http_lock&.owned?
     end
     # rubocop:enable Metrics/BlockLength
 

data/lib/matrix_sdk/room.rb

@@ -28,12 +28,14 @@ module MatrixSdk
     #   An inspect method that skips a handful of instance variables to avoid
     #   flooding the terminal with debug data.
     #   @return [String] a regular inspect string without the data for some variables
-    ignore_inspect :client, :events, :prev_batch, :logger
+    ignore_inspect :client, :events, :prev_batch, :logger, :tinycache_adapter
 
     # Requires heavy lookups, so they're cached for an hour
-    cached :joined_members, :aliases, cache_level: :all, expires_in: 60 * 60
-    # Only cache unfiltered requests for all members
-    cached :all_members, unless: proc { |args| args.any? }, cache_level: :all, expires_in: 3600
+    cached :joined_members, cache_level: :all, expires_in: 60 * 60
+
+    # Only cache unfiltered requests for aliases and members
+    cached :aliases, unless: proc { |args| args.any? }, cache_level: :all, expires_in: 60 * 60
+    cached :all_members, unless: proc { |args| args.any? }, cache_level: :all, expires_in: 60 * 60
 
     # Much simpler to look up, and lighter data-wise, so the cache is wider
     cached :canonical_alias, :name, :avatar_url, :topic, :guest_access, :join_rule, :power_levels, cache_level: :some, expires_in: 15 * 60
@@ -53,7 +55,7 @@ module MatrixSdk
     # @option data [String] :topic The current topic of the room
     # @option data [String,MXID] :canonical_alias The canonical alias of the room
     # @option data [Array(String,MXID)] :aliases All non-canonical aliases of the room
-    # @option data [:invite,:public] :join_rule The join rule for the room
+    # @option data [:invite,:public,:knock] :join_rule The join rule for the room
     # @option data [:can_join,:forbidden] :guest_access The guest access setting for the room
     # @option data [Boolean] :world_readable If the room is readable by the entire world
     # @option data [Array(User)] :members The list of joined members
@@ -63,6 +65,13 @@ module MatrixSdk
     # @option data [String,URI] :avatar_url The avatar URL for the room
     # @option data [String] :prev_batch The previous batch token for backfill
     def initialize(client, room_id, data = {})
+      if client.is_a? Room
+        copy = client
+        client = copy.client
+        room_id = copy.id
+        # data = copy.attributes
+      end
+
       raise ArgumentError, 'Must be given a Client instance' unless client.is_a? Client
 
       @client = client
@@ -71,6 +80,7 @@ module MatrixSdk
 
       @events = []
       @event_history_limit = 10
+      @room_type = nil
 
       @prev_batch = nil
 
@@ -89,6 +99,24 @@ module MatrixSdk
       logger.debug "Created room #{room_id}"
     end
 
+    #
+    # Casting operators
+    #
+
+    def to_space
+      return nil unless space?
+
+      Rooms::Space.new self, nil
+    end
+
+    def to_s
+      prefix = canonical_alias if canonical_alias_has_value?
+      prefix ||= id
+      return "#{prefix} | #{name}" if name_has_value?
+
+      prefix
+    end
+
     #
     # Event handlers
     #
@@ -204,14 +232,14 @@ module MatrixSdk
     #
     # @return [:can_join,:forbidden] The current guest access right
     def guest_access
-      client.api.get_room_guest_access(id)[:guest_access].to_sym
+      client.api.get_room_guest_access(id)[:guest_access]&.to_sym
     end
 
     # Gets the join rule for the room
     #
     # @return [:public,:knock,:invite,:private] The current join rule
     def join_rule
-      client.api.get_room_join_rules(id)[:join_rule].to_sym
+      client.api.get_room_join_rules(id)[:join_rule]&.to_sym
     end
 
     # Checks if +guest_access+ is set to +:can_join+
@@ -224,11 +252,16 @@ module MatrixSdk
       join_rule == :invite
     end
 
+    # Checks if +join_rule+ is set to +:knock+
+    def knock_only?
+      join_rule == :knock
+    end
+
     # Gets the history visibility of the room
     #
     # @return [:invited,:joined,:shared,:world_readable] The current history visibility for the room
     def history_visibility
-      client.api.get_room_state(id, 'm.room.history_visibility')[:history_visibility].to_sym
+      client.api.get_room_state(id, 'm.room.history_visibility')[:history_visibility]&.to_sym
     end
 
     # Checks if the room history is world readable
@@ -241,15 +274,14 @@ module MatrixSdk
 
     # Gets the room aliases
     #
+    # @param canonical_only [Boolean] Should the list of aliases only contain the canonical ones
     # @return [Array[String]] The assigned room aliases
-    def aliases
-      client.api.get_room_aliases(id).aliases
-    rescue MatrixNotFoundError
-      data = client.api.get_room_state_all(id)
-      data.select { |chunk| chunk[:type] == 'm.room.aliases' && chunk.key?(:content) && chunk[:content].key?(:aliases) }
-          .map { |chunk| chunk[:content][:aliases] }
-          .flatten
-          .compact
+    def aliases(canonical_only: true)
+      canonical = client.api.get_room_state(id, 'm.room.canonical_alias') rescue {}
+      aliases = ([canonical[:alias]].compact + (canonical[:alt_aliases] || [])).uniq.sort
+      return aliases if canonical_only
+
+      (aliases + client.api.get_room_aliases(id).aliases).uniq.sort
     end
 
     #
@@ -499,6 +531,41 @@ module MatrixSdk
       true
     end
 
+    # Gets the room creation information
+    #
+    # @return [Response] The content of the m.room.create event
+    def creation_info
+      # Not caching here, easier to cache the important values separately instead
+      client.api.get_room_creation_info(id)
+    end
+
+    # Retrieves the type of the room
+    #
+    # @return ['m.space',String,nil] The type of the room
+    def room_type
+      # Can't change, so a permanent cache is ok
+      return @room_type if @room_type_retrieved || @room_type
+
+      @room_type_retrieved = true
+      @room_type ||= creation_info[:type]
+    end
+
+    # Retrieves the room version
+    #
+    # @return [String] The version of the room
+    def room_version
+      @room_version ||= creation_info[:room_version]
+    end
+
+    # Checks if the room is a Matrix Space
+    #
+    # @return [Boolean,nil] True if the room is a space
+    def space?
+      room_type == 'm.space'
+    rescue MatrixSdk::MatrixForbiddenError, MatrixSdk::MatrixNotFoundError
+      nil
+    end
+
     # Returns a list of the room tags
     #
     # @return [Response] A list of the tags and their data, with add and remove methods implemented
@@ -646,10 +713,10 @@ module MatrixSdk
 
     # Sets a new avatar URL for the room
     #
-    # @param avatar_url [URI::MATRIX] The mxc:// URL for the new room avatar
+    # @param avatar_url [URI::MXC] The mxc:// URL for the new room avatar
     def avatar_url=(avatar_url)
       avatar_url = URI(avatar_url) unless avatar_url.is_a? URI
-      raise ArgumentError, 'Must be a valid MXC URL' unless avatar_url.is_a? URI::MATRIX
+      raise ArgumentError, 'Must be a valid MXC URL' unless avatar_url.is_a? URI::MXC
 
       client.api.set_room_avatar(id, avatar_url)
       tinycache_adapter.write(:avatar_url, avatar_url)
@@ -676,7 +743,7 @@ module MatrixSdk
       user = MXID.new(user.to_s) unless user.is_a? MXID
       raise ArgumentError, 'Must provide a valid user or MXID' unless user.user?
 
-      level = power_levels[:users][user.to_s.to_sym]
+      level = power_levels.dig(:users, user.to_s.to_sym)
       level = power_levels[:users_default] || 0 if level.nil? && use_default
       level
     end
@@ -751,8 +818,17 @@ module MatrixSdk
 
       if users
         data[:users] = {} unless data.key? :users
-        data[:users].merge!(users)
-        data[:users].delete_if { |_k, v| v.nil? }
+        users.each do |user, level|
+          user = user.id if user.is_a? User
+          user = MXID.new(user.to_s) unless user.is_a? MXID
+          raise ArgumentError, 'Must provide a valid user or MXID' unless user.user?
+
+          if level.nil?
+            data[:users].delete(user.to_s.to_sym)
+          else
+            data[:users][user.to_s.to_sym] = level
+          end
+        end
       end
 
       client.api.set_power_levels(id, data)
@@ -796,27 +872,27 @@ module MatrixSdk
     end
 
     def handle_room_name(event)
-      tinycache_adapter.write(:name, event[:content][:name])
+      tinycache_adapter.write(:name, event.dig(*%i[content name]))
     end
 
     def handle_room_topic(event)
-      tinycache_adapter.write(:topic, event[:content][:topic])
+      tinycache_adapter.write(:topic, event.dig(*%i[content topic]))
     end
 
     def handle_room_guest_access(event)
-      tinycache_adapter.write(:guest_access, event[:content][:guest_access].to_sym)
+      tinycache_adapter.write(:guest_access, event.dig(*%i[content guest_access])&.to_sym)
     end
 
     def handle_room_join_rules(event)
-      tinycache_adapter.write(:join_rule, event[:content][:join_rule].to_sym)
+      tinycache_adapter.write(:join_rule, event.dig(*%i[content join_rule])&.to_sym)
     end
 
     def handle_room_member(event)
       return unless client.cache == :all
 
-      if event[:content][:membership] == 'join'
+      if event.dig(*%i[content membership]) == 'join'
         ensure_member(client.get_user(event[:state_key]).dup.tap do |u|
-          u.instance_variable_set :@display_name, event[:content][:displayname]
+          u.instance_variable_set(:@display_name, event.dig(*%i[content displayname]))
         end)
       elsif tinycache_adapter.exist? :joined_members
         members = tinycache_adapter.read(:joined_members)
@@ -825,20 +901,12 @@ module MatrixSdk
     end
 
     def handle_room_canonical_alias(event)
-      canonical_alias = tinycache_adapter.write :canonical_alias, event[:content][:alias]
+      canonical_alias = tinycache_adapter.write(:canonical_alias, event.dig(*%i[content alias]))
 
       data = tinycache_adapter.read(:aliases) || []
       data << canonical_alias
-      tinycache_adapter.write(:aliases, data)
-    end
-
-    def handle_room_aliases(event)
-      tinycache_adapter.write(:aliases, []) unless tinycache_adapter.exist? :aliases
-
-      aliases = tinycache_adapter.read(:aliases) || []
-      aliases.concat event[:content][:aliases]
-
-      tinycache_adapter.write(:aliases, aliases)
+      data += event.dig(*%i[content alt_aliases]) || []
+      tinycache_adapter.write(:aliases, data.uniq.sort)
     end
 
     def room_handlers?
@@ -854,7 +922,6 @@ module MatrixSdk
     end
 
     INTERNAL_HANDLERS = {
-      'm.room.aliases' => :handle_room_aliases,
       'm.room.canonical_alias' => :handle_room_canonical_alias,
       'm.room.guest_access' => :handle_room_guest_access,
       'm.room.join_rules' => :handle_room_join_rules,

data/lib/matrix_sdk/rooms/space.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module MatrixSdk::Rooms
+  class Space < MatrixSdk::Room
+    TYPE = 'm.space'
+
+    def tree(suggested_only: nil, max_rooms: nil)
+      begin
+        data = client.api.request :get, :client_r0, "/rooms/#{id}/spaces", query: {
+          suggested_only: suggested_only,
+          max_rooms_per_space: max_rooms
+        }.compact
+      rescue MatrixRequestError
+        data = client.api.request :get, :client_unstable, "/org.matrix.msc2946/rooms/#{id}/spaces", query: {
+          suggested_only: suggested_only,
+          max_rooms_per_space: max_rooms
+        }.compact
+      end
+
+      rooms = data.rooms.map do |r|
+        next if r[:room_id] == id
+
+        room = client.ensure_room(r[:room_id])
+        room.instance_variable_set :@room_type, r[:room_type] if r.key? :room_type
+        room = room.to_space if room.space?
+
+        # Inject available room information
+        r.each do |k, v|
+          if room.respond_to?("#{k}_cached?".to_sym) && send("#{k}_cached?".to_sym)
+            room.send(:tinycache_adapter).write(k, v)
+          elsif room.instance_variable_defined? "@#{k}"
+            room.instance_variable_set("@#{k}", v)
+          end
+        end
+        room
+      end
+      rooms.compact!
+
+      grouping = {}
+      data.events.each do |ev|
+        next unless ev[:type] == 'm.space.child'
+        next unless ev[:content].key? :via
+
+        d = (grouping[ev[:room_id]] ||= [])
+        d << ev[:state_key]
+      end
+
+      build_tree = proc do |entry|
+        next if entry.nil?
+
+        room = self if entry == id
+        room ||= rooms.find { |r| r.id == entry }
+        puts "Unable to find room for entry #{entry}" unless room
+        # next if room.nil?
+
+        ret = {
+          room => []
+        }
+
+        grouping[entry]&.each do |child|
+          if grouping.key?(child)
+            ret[room] << build_tree.call(child)
+          else
+            child_r = self if child == id
+            child_r ||= rooms.find { |r| r.id == child }
+
+            ret[room] << child_r
+          end
+        end
+
+        ret[room].compact!
+
+        ret
+      end
+
+      build_tree.call(id)
+    end
+  end
+end

data/lib/matrix_sdk/user.rb

@@ -59,7 +59,7 @@ module MatrixSdk
     # Only works for the current user object, as requested by
     #     client.get_user(:self)
     #
-    # @param url [String,URI::MATRIX] the new avatar URL
+    # @param url [String,URI::MXC] the new avatar URL
     # @note Requires a mxc:// URL, check example on
     #   {MatrixSdk::Protocols::CS#set_avatar_url} for how this can be done
     # @see MatrixSdk::Protocols::CS#set_avatar_url
@@ -74,7 +74,7 @@ module MatrixSdk
     # @see MatrixSdk::Protocols::CS#get_presence_status
     # @note This information is not cached in the abstraction layer
     def presence
-      raw_presence[:presence].to_sym
+      raw_presence[:presence]&.to_sym
     end
 
     # Sets the user's current presence status
@@ -132,8 +132,8 @@ module MatrixSdk
 
     # Returns all the current device keys for the user, retrieving them if necessary
     def device_keys
-      @device_keys ||= client.api.keys_query(device_keys: { id => [] }).yield_self do |resp|
-        resp[:device_keys][id.to_sym]
+      @device_keys ||= client.api.keys_query(device_keys: { id => [] }).yield_self do |resp| # rubocop:disable Style/ObjectThen # Keep Ruby 2.5 support a little longer
+        resp.dig(:device_keys, id.to_sym)
       end
     end
 

data/lib/matrix_sdk/util/events.rb

@@ -22,13 +22,11 @@ module MatrixSdk
 
     def fire(event, filter = nil)
       reverse_each do |_k, h|
-        begin
-          h[:block].call(event) if !h[:filter] || event.matches?(h[:filter], filter)
-        rescue StandardError => e
-          logger.error "#{e.class.name} occurred when firing event (#{event})\n#{e}"
+        h[:block].call(event) if !h[:filter] || event.matches?(h[:filter], filter)
+      rescue StandardError => e
+        logger.error "#{e.class.name} occurred when firing event (#{event})\n#{e}"
 
-          raise e if @reraise_exceptions
-        end
+        raise e if @reraise_exceptions
       end
     end
   end

data/lib/matrix_sdk/util/extensions.rb

@@ -1,19 +1,6 @@
 # frozen_string_literal: true
 
-require 'uri'
-
-module URI
-  # A mxc:// Matrix content URL
-  class MATRIX < Generic
-    def full_path
-      select(:host, :port, :path, :query, :fragment)
-        .reject(&:nil?)
-        .join
-    end
-  end
-
-  @@schemes['MXC'] = MATRIX
-end
+require 'pp'
 
 unless Object.respond_to? :yield_self
   class Object
@@ -66,13 +53,20 @@ module MatrixSdk
 
     def ignore_inspect(*symbols)
       class_eval %*
-        def inspect
-          reentrant = caller_locations.any? { |l| l.absolute_path == __FILE__ && l.label == 'inspect' }
-          "\#{to_s[0..-2]} \#{instance_variables
+        include PP::ObjectMixin
+
+        def pretty_print_instance_variables
+          instance_variables
             .reject { |f| %i[#{symbols.map { |s| "@#{s}" }.join ' '}].include? f }
-            .map { |f| "\#{f}=\#{reentrant ? instance_variable_get(f) : instance_variable_get(f).inspect}" }.join " " }}>"
+            .sort
+        end
+
+        def pretty_print(pp)
+          pp.pp_object(self)
         end
-      *, __FILE__, __LINE__ - 7
+
+        alias inspect pretty_print_inspect
+      *, __FILE__, __LINE__ - 14
     end
   end
 

data/lib/matrix_sdk/util/tinycache.rb

@@ -20,7 +20,7 @@ module MatrixSdk::Util
 
     def self.extended(base)
       helper_name = base.send(:cache_helper_module_name)
-      base.remove_const(helper_name) if base.const_defined?(helper_name)
+      base.send :remove_const, helper_name if base.const_defined?(helper_name)
       base.prepend base.const_set(helper_name, Module.new)
 
       base.include InstanceMethods
@@ -62,23 +62,38 @@ module MatrixSdk::Util
       method_names = build_method_names(method_name)
       tinycache_adapter_config[method_name] = {
         level: cache_level,
-        expires: expires_in || 1 * 365 * 24 * 60 * 60 # 1 year
+        expires: expires_in || (1 * 365 * 24 * 60 * 60) # 1 year
       }
 
-      const_get(cache_helper_module_name).class_eval do
+      helper = const_get(cache_helper_module_name)
+      return if method_names.any? { |k, _| helper.respond_to? k }
+
+      helper.class_eval do
         define_method(method_names[:cache_key]) do |*args|
           cache_key.call(method_name, args)
         end
 
         define_method(method_names[:with_cache]) do |*args|
           tinycache_adapter.fetch(__send__(method_names[:cache_key], *args), expires_in: expires_in) do
-            __send__(method_names[:without_cache], *args)
+            named = args.delete_at(-1) if args.last.is_a? Hash
+
+            if named
+              __send__(method_names[:without_cache], *args, **named)
+            else
+              __send__(method_names[:without_cache], *args)
+            end
           end
         end
 
         define_method(method_names[:without_cache]) do |*args|
           orig = method(method_name).super_method
-          orig.call(*args)
+          named = args.delete_at(-1) if args.last.is_a? Hash
+
+          if named
+            orig.call(*args, **named)
+          else
+            orig.call(*args)
+          end
         end
 
         define_method(method_names[:clear_cache]) do |*args|
@@ -89,11 +104,19 @@ module MatrixSdk::Util
           true
         end
 
+        define_method(method_names[:has_value]) do |*args|
+          tinycache_adapter.valid?(__send__(method_names[:cache_key], *args))
+        end
+
         define_method(method_name) do |*args|
           unless_proc = opts[:unless].is_a?(Symbol) ? opts[:unless].to_proc : opts[:unless]
 
+          raise ArgumentError, 'Invalid proc provided (must have arity between 1..3)' if unless_proc && !(1..3).include?(unless_proc.arity)
+
           skip_cache = false
-          skip_cache ||= unless_proc&.call(self, method_name, args)
+          skip_cache ||= unless_proc.call(self, method_name, args) if unless_proc&.arity == 3
+          skip_cache ||= unless_proc.call(method_name, args) if unless_proc&.arity == 2
+          skip_cache ||= unless_proc.call(args) if unless_proc&.arity == 1
           skip_cache ||= CACHE_LEVELS[client&.cache || :all] < CACHE_LEVELS[cache_level]
 
           if skip_cache
@@ -115,7 +138,8 @@ module MatrixSdk::Util
         with_cache: "#{method_name}_with_cache#{punctuation}",
         without_cache: "#{method_name}_without_cache#{punctuation}",
         clear_cache: "clear_#{method_name}_cache#{punctuation}",
-        cached: "#{method}_cached?"
+        cached: "#{method}_cached?",
+        has_value: "#{method}_has_value?"
       }
     end
   end

data/lib/matrix_sdk/util/tinycache_adapter.rb

@@ -16,6 +16,7 @@ module MatrixSdk::Util
 
     def write(key, value, expires_in: nil, cache_level: nil)
       expires_in ||= config.dig(key, :expires)
+      expires_in ||= 24 * 60 * 60
       cache_level ||= client&.cache
       cache_level ||= :all
       cache_level = Tinycache::CACHE_LEVELS[cache_level] unless cache_level.is_a? Integer
@@ -30,6 +31,10 @@ module MatrixSdk::Util
       cache.key?(key)
     end
 
+    def valid?(key)
+      exist?(key) && !cache[key].expired?
+    end
+
     def fetch(key, expires_in: nil, cache_level: nil, **_opts)
       expires_in ||= config.dig(key, :expires)
       cache_level ||= client&.cache

data/lib/matrix_sdk/util/uri.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module URI
+  # A mxc:// Matrix content URL
+  class MXC < Generic
+    def full_path
+      select(:host, :port, :path, :query, :fragment)
+        .compact
+        .join
+    end
+  end
+
+  # TODO: Use +register_scheme+ on Ruby >=3.1 and fall back to old behavior
+  # for older Rubies. May be removed at EOL of Ruby 3.0.
+  if respond_to? :register_scheme
+    register_scheme 'MXC', MXC
+  else
+    @@schemes['MXC'] = MXC
+  end
+
+  unless scheme_list.key? 'MATRIX'
+    # A matrix: URI according to MSC2312
+    class MATRIX < Generic
+      attr_reader :authority, :action, :mxid, :mxid2, :via
+
+      def initialize(*args)
+        super(*args)
+
+        @action = nil
+        @authority = nil
+        @mxid = nil
+        @mxid2 = nil
+        @via = nil
+
+        raise InvalidComponentError, 'missing opaque part for matrix URL' if !@opaque && !@path
+
+        if @path
+          @authority = @host
+          @authority += ":#{@port}" if @port
+        else
+          @path, @query = @opaque.split('?')
+          @query, @fragment = @query.split('#') if @query&.include? '#'
+          @path, @fragment = @path.split('#') if @path&.include? '#'
+          @path = "/#{path}"
+          @opaque = nil
+        end
+
+        components = @path.delete_prefix('/').split('/', -1)
+        raise InvalidComponentError, 'component count must be 2 or 4' if components.size != 2 && components.size != 4
+
+        sigil = case components.shift
+                when 'u', 'user'
+                  '@'
+                when 'r', 'room'
+                  '#'
+                when 'roomid'
+                  '!'
+                else
+                  raise InvalidComponentError, 'invalid component in path'
+                end
+
+        component = components.shift
+        raise InvalidComponentError, "component can't be empty" if component.nil? || component.empty?
+
+        @mxid = MatrixSdk::MXID.new("#{sigil}#{component}")
+
+        if components.size == 2
+          sigil2 = case components.shift
+                   when 'e', 'event'
+                     '$'
+                   else
+                     raise InvalidComponentError, 'invalid component in path'
+                   end
+          component = components.shift
+          raise InvalidComponentError, "component can't be empty" if component.nil? || component.empty?
+
+          @mxid2 = MatrixSdk::MXID.new("#{sigil2}#{component}")
+        end
+
+        return unless @query
+
+        @action = @query.match(/action=([^&]+)/)&.captures&.first&.to_sym
+        @via = @query.scan(/via=([^&]+)/)&.flatten&.compact
+      end
+
+      def mxid2?
+        !@mxid2.nil?
+      end
+    end
+
+    # TODO: Use +register_scheme+ on Ruby >=3.1 and fall back to old behavior
+    # for older Rubies. May be removed at EOL of Ruby 3.0.
+    if respond_to? :register_scheme
+      register_scheme 'MATRIX', MATRIX
+    else
+      @@schemes['MATRIX'] = MATRIX
+    end
+  end
+end

data/lib/matrix_sdk/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MatrixSdk
-  VERSION = '2.3.0'
+  VERSION = '2.6.0'
 end