openhab-scripting 5.35.1 → 5.36.0

data/lib/openhab/core/items/proxy.rb

@@ -13,88 +13,42 @@ module OpenHAB
         # @!parse include Item
 
         # @!visibility private
-        EVENTS = [Events::ItemAddedEvent::TYPE, Events::ItemUpdatedEvent::TYPE, Events::ItemRemovedEvent::TYPE].freeze
+        EVENTS = [Events::ItemAddedEvent::TYPE,
+                  Events::ItemUpdatedEvent::TYPE,
+                  Events::ItemRemovedEvent::TYPE].freeze
         # @!visibility private
         UID_METHOD = :name
+        # @!visibility private
+        UID_TYPE = String
 
         include Core::Proxy
 
         # @return [String]
         attr_reader :name
 
-        #
-        # Set the proxy item (called by super)
-        #
-        def __setobj__(item)
-          @item = item.is_a?(Item) ? item : nil
-          @name ||= item.name if item
-        end
-
-        #
-        # @return [Item, nil]
-        #
-        def __getobj__
-          @item
-        end
-
         # @return [Module]
         def class
-          return Item if __getobj__.nil?
+          target = __getobj__
+          return Item if target.nil?
 
-          __getobj__.class
+          target.class
         end
 
         # @return [true, false]
         def is_a?(klass)
-          obj = __getobj__
+          target = __getobj__
           # only claim to be a Delegator if we're backed by an actual item at the moment
-          klass == Item || obj.is_a?(klass) || klass == Proxy || (!obj.nil? && super)
+          klass == Item || target.is_a?(klass) || klass == Proxy || (target.nil? && super)
         end
         alias_method :kind_of?, :is_a?
 
-        #
-        # Need to check if `self` _or_ the delegate is an instance of the
-        # given class
-        #
-        # So that {#==} can work
-        #
-        # @return [true, false]
-        #
-        # @!visibility private
-        def instance_of?(klass)
-          __getobj__.instance_of?(klass) || super
-        end
-
-        #
-        # Check if delegates are equal for comparison
-        #
-        # Otherwise items can't be used in Java maps
-        #
-        # @return [true, false]
-        #
-        # @!visibility private
-        def ==(other)
-          return __getobj__ == other.__getobj__ if other.instance_of?(Proxy)
-
-          super
-        end
-
-        #
-        # Non equality comparison
-        #
-        # @return [true, false]
-        #
-        # @!visibility private
-        def !=(other)
-          !(self == other) # rubocop:disable Style/InverseMethods
-        end
-
         # @return [GroupItem::Members]
-        # @raise [NoMethodError] if item is not a GroupItem, or a dummy.
+        # @raise [NoMethodError] if item is neither a GroupItem, nor a dummy.
         def members
-          return GroupItem::Members.new(self) if __getobj__.nil?
+          target = __getobj__
+          return GroupItem::Members.new(self) if target.nil?
 
-          __getobj__.members
+          target.members
         end
 
         # Several methods can just return nil when it's a dummy item
@@ -126,45 +80,30 @@ module OpenHAB
           RUBY
         end
 
-        # @return [String]
-        def to_s
-          return name if __getobj__.nil?
-
-          __getobj__.to_s
-        end
-
-        # @return [String]
-        def inspect
-          return super unless __getobj__.nil?
-
-          "#<OpenHAB::Core::Items::Proxy #{name}>"
+        # needs to return `true` for dummies for #members, false
+        # for non-dummies that aren't actually groups
+        def respond_to?(method, include_private = false) # rubocop:disable Style/OptionalBooleanParameter
+          target = __getobj__
+          if target.nil?
+            return true if Item.method_defined?(method)
+          elsif method.to_sym == :members
+            return target.respond_to?(method)
+          end
+
+          target.respond_to?(method, include_private) || super
         end
 
-        #
-        # Supports inspect from IRB when we're a dummy item.
-        #
-        # @return [void]
-        # @!visibility private
-        def pretty_print(printer)
-          return super unless __getobj__.nil?
+        private
 
-          printer.text(inspect)
-        end
-
-        # needs to return `false` if we know we're not a {GroupItem}
-        def respond_to?(method, *args)
-          obj = __getobj__
-          return obj.respond_to?(method, *args) if method.to_sym == :members && !obj.nil?
-
-          super
-        end
+        # ditto
+        def target_respond_to?(target, method, include_private)
+          if method.to_sym == :members
+            return true if target.nil?
 
-        # needs to return `false` if we know we're not a {GroupItem}
-        def respond_to_missing?(method, *args)
-          obj = __getobj__
-          return obj.respond_to_missing?(method, *args) if method.to_sym == :members && !obj.nil?
+            return target.respond_to?(method, include_private)
+          end
 
-          super
+          target.respond_to?(method, include_private)
         end
       end
     end

data/lib/openhab/core/items/registry.rb

@@ -54,7 +54,7 @@ module OpenHAB
         # @see DSL::Items::Builder DSL::Items::Builder for more details and examples
         #
         def build(preferred_provider = nil, update: true, &block)
-          DSL::Items::BaseBuilderDSL.new(preferred_provider, update: update)
+          DSL::Items::BaseBuilderDSL.new(preferred_provider, update:)
                                     .instance_eval_with_dummy_items(&block)
         end
 

data/lib/openhab/core/items/semantics/enumerable.rb

@@ -199,6 +199,6 @@ module Enumerable
   # @return [self]
   #
   def toggle(source: nil)
-    each { |i| i.toggle(source: source) }
+    each { |i| i.toggle(source:) }
   end
 end

data/lib/openhab/core/items/semantics/provider.rb

@@ -8,11 +8,7 @@ module OpenHAB
         # Provides {SemanticTag SemanticTags} created in Ruby to openHAB
         #
         class Provider < Core::Provider
-          begin
-            include org.openhab.core.semantics.SemanticTagProvider
-          rescue NameError
-            # @deprecated OH3.4
-          end
+          include org.openhab.core.semantics.SemanticTagProvider
 
           class << self
             #

data/lib/openhab/core/items/semantics/semantic_tag.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-# @deprecated OH3.4
-return unless OpenHAB::Core::Items::Semantics::Provider.registry
-
 module OpenHAB
   module Core
     module Items

data/lib/openhab/core/items/semantics.rb

@@ -61,11 +61,8 @@ module OpenHAB
       # and {#property_type}. They can even be used with
       # {DSL::Items::ItemBuilder#tag}.
       #
-      # In openHAB 4.0, all of the tag objects implement {SemanticTag}.
+      # All of the tag objects implement {SemanticTag}.
       #
-      # In openHAB 3.4, the constants in the {Semantics} module are enhanced with {TagClassMethods}
-      # to provide easy access to the tags' additional attributes: {TagClassMethods#label label},
-      # {TagClassMethods#synonyms synonyms}, and {TagClassMethods#description description}.
       # For example, to get the synonyms for `Semantics::Lightbulb` in German:
       # `Semantics::Lightbulb.synonyms(java.util.Locale::GERMAN)`
       #
@@ -173,7 +170,7 @@ module OpenHAB
       # For more information, see {add}
       #
       module Semantics
-        GenericItem.include(self)
+        Item.include(self)
         GroupItem.extend(Forwardable)
         GroupItem.def_delegators :members, :equipments, :locations
 
@@ -198,17 +195,7 @@ module OpenHAB
           # @return [Array<SemanticTag>] an array containing all the Semantic tags
           #
           def tags
-            # @deprecated OH3.4 missing registry
-            if Provider.registry
-              Provider.registry.all.to_a
-            else
-              java.util.stream.Stream.of(
-                org.openhab.core.semantics.model.point.Points.stream,
-                org.openhab.core.semantics.model.property.Properties.stream,
-                org.openhab.core.semantics.model.equipment.Equipments.stream,
-                org.openhab.core.semantics.model.location.Locations.stream
-              ).flat_map(&:itself).map(&:ruby_class).iterator.to_a
-            end
+            Provider.registry.all.to_a
           end
 
           #
@@ -217,35 +204,19 @@ module OpenHAB
           # @param [String,Symbol] id The tag name, label, or synonym to look up
           # @param [java.util.Locale] locale The locale of the given label or synonym
           #
-          # @return [SemanticTag, Module, nil] The semantic tag class if found, or nil if not found.
-          #   In openHAB 4.0, a SemanticTag instance will be returned. In openHAB 3.4, it will be
-          #   a Module.
+          # @return [SemanticTag, nil] The semantic tag class if found, or nil if not found.
           #
           def lookup(id, locale = java.util.Locale.default)
             id = id.to_s
 
-            # @deprecated OH3.4 - the Property tag had an ID of "MeasurementProperty" in OH3.4.
-            # This was corrected in OH4.
-            id = "MeasurementProperty" if id == "Property" && Core.version < Core::V4_0
-
-            # @deprecated OH3.4 missing registry
-            if Provider.registry
-              tag = service.get_by_label_or_synonym(id, locale)
-              tag = nil if tag&.empty?
-              tag_class = tag&.first ||
-                          Provider.registry.get_tag_class_by_id(id)
-              return unless tag_class
-
-              Provider.registry.get(Provider.registry.class.build_id(tag_class))
-            else
-              tag = org.openhab.core.semantics.SemanticTags.get_by_label_or_synonym(id, locale).first ||
-                    org.openhab.core.semantics.SemanticTags.get_by_id(id)
-              return unless tag
-
-              tag = tag.ruby_class
-              tag.singleton_class.include(TagClassMethods)
-              tag
-            end
+            # Java21 added #first method, which overrides Ruby's #first.
+            # It throws an error if the list is Empty instead of returning nil.
+            # So we use #ruby_first to ensure we get Ruby's behaviour
+            tag_class = service.get_by_label_or_synonym(id, locale).ruby_first ||
+                        Provider.registry.get_tag_class_by_id(id)
+            return unless tag_class
+
+            Provider.registry.get(Provider.registry.class.build_id(tag_class))
           end
 
           #
@@ -256,118 +227,111 @@ module OpenHAB
             logger.trace { "const missing, performing Semantics Lookup for: #{sym}" }
             lookup(sym)&.tap { |tag| const_set(sym, tag) } || super
           end
-        end
 
-        # @deprecated OH3.4 cannot add a tag
-        # this not in the class << self block above because YARD doesn't figure out
-        # it's a class method with the conditional
-        if Provider.registry
-          class << self
-            #
-            # Adds custom semantic tags.
-            #
-            # @since openHAB 4.0
-            # @return [Array<SemanticTag>] An array of tags successfully added.
-            #
-            # @overload add(**tags)
-            #   Quickly add one or more semantic tags using the default label, empty synonyms and descriptions.
-            #
-            #   @param [kwargs] **tags Pairs of `tag` => `parent` where tag is either a `Symbol` or a `String`
-            #     for the tag to be added, and parent is either a {SemanticTag}, a `Symbol` or a `String` of an
-            #     existing tag.
-            #   @return [Array<SemanticTag>] An array of tags successfully added.
-            #
-            #   @example Add one semantic tag `Balcony` whose parent is `Semantics::Outdoor` (Location)
-            #     Semantics.add(Balcony: Semantics::Outdoor)
-            #
-            #   @example Add multiple semantic tags
-            #     Semantics.add(Balcony: Semantics::Outdoor,
-            #                   SecretRoom: Semantics::Room,
-            #                   Motion: Semantics::Property)
-            #
-            # @overload add(label: nil, synonyms: "", description: "", **tags)
-            #   Add a custom semantic tag with extra details.
-            #
-            #   @example
-            #     Semantics.add(SecretRoom: Semantics::Room, label: "My Secret Room",
-            #       synonyms: "HidingPlace", description: "A room that requires a special trick to enter")
-            #
-            #   @param [String,nil] label Optional label. When `nil`, infer the label from the tag name,
-            #     converting `CamelCase` to `Camel Case`
-            #   @param [String,Symbol,Array<String,Symbol>] synonyms Additional synonyms to refer to this tag.
-            #   @param [String] description A longer description of the tag.
-            #   @param [kwargs] **tags Exactly one pair of `tag` => `parent` where tag is either a `Symbol` or a
-            #     `String` for the tag to be added, and parent is either a {SemanticTag}, a `Symbol` or a
-            #     `String` of an existing tag.
-            #   @return [Array<SemanticTag>] An array of tags successfully added.
-            #
-            def add(label: nil, synonyms: "", description: "", **tags)
-              raise ArgumentError, "Tags must be specified" if tags.empty?
-              if (tags.length > 1) && !(label.nil? && synonyms.empty? && description.empty?)
-                raise ArgumentError, "Additional options can only be specified when creating one tag"
-              end
+          #
+          # Adds custom semantic tags.
+          #
+          # @since openHAB 4.0
+          # @return [Array<SemanticTag>] An array of tags successfully added.
+          #
+          # @overload add(**tags)
+          #   Quickly add one or more semantic tags using the default label, empty synonyms and descriptions.
+          #
+          #   @param [kwargs] **tags Pairs of `tag` => `parent` where tag is either a `Symbol` or a `String`
+          #     for the tag to be added, and parent is either a {SemanticTag}, a `Symbol` or a `String` of an
+          #     existing tag.
+          #   @return [Array<SemanticTag>] An array of tags successfully added.
+          #
+          #   @example Add one semantic tag `Balcony` whose parent is `Semantics::Outdoor` (Location)
+          #     Semantics.add(Balcony: Semantics::Outdoor)
+          #
+          #   @example Add multiple semantic tags
+          #     Semantics.add(Balcony: Semantics::Outdoor,
+          #                   SecretRoom: Semantics::Room,
+          #                   Motion: Semantics::Property)
+          #
+          # @overload add(label: nil, synonyms: "", description: "", **tags)
+          #   Add a custom semantic tag with extra details.
+          #
+          #   @example
+          #     Semantics.add(SecretRoom: Semantics::Room, label: "My Secret Room",
+          #       synonyms: "HidingPlace", description: "A room that requires a special trick to enter")
+          #
+          #   @param [String,nil] label Optional label. When `nil`, infer the label from the tag name,
+          #     converting `CamelCase` to `Camel Case`
+          #   @param [String,Symbol,Array<String,Symbol>] synonyms Additional synonyms to refer to this tag.
+          #   @param [String] description A longer description of the tag.
+          #   @param [kwargs] **tags Exactly one pair of `tag` => `parent` where tag is either a `Symbol` or a
+          #     `String` for the tag to be added, and parent is either a {SemanticTag}, a `Symbol` or a
+          #     `String` of an existing tag.
+          #   @return [Array<SemanticTag>] An array of tags successfully added.
+          #
+          def add(label: nil, synonyms: "", description: "", **tags)
+            raise ArgumentError, "Tags must be specified" if tags.empty?
+            if (tags.length > 1) && !(label.nil? && synonyms.empty? && description.empty?)
+              raise ArgumentError, "Additional options can only be specified when creating one tag"
+            end
 
-              synonyms = Array.wrap(synonyms).map { |s| s.to_s.strip }
+            synonyms = Array.wrap(synonyms).map { |s| s.to_s.strip }
 
-              tags.map do |name, parent|
-                if (existing_tag = lookup(name))
-                  logger.warn("Tag already exists: #{existing_tag.inspect}")
-                  next
-                end
+            tags.filter_map do |name, parent|
+              if (existing_tag = lookup(name))
+                logger.warn("Tag already exists: #{existing_tag.inspect}")
+                next
+              end
 
-                unless parent.is_a?(SemanticTag)
-                  parent_tag = lookup(parent)
-                  raise ArgumentError, "Unknown parent: #{parent}" unless parent_tag
+              unless parent.is_a?(SemanticTag)
+                parent_tag = lookup(parent)
+                raise ArgumentError, "Unknown parent: #{parent}" unless parent_tag
 
-                  parent = parent_tag
-                end
+                parent = parent_tag
+              end
 
-                new_tag = org.openhab.core.semantics.SemanticTagImpl.new("#{parent.uid}_#{name}",
-                                                                         label,
-                                                                         description,
-                                                                         synonyms)
-                Provider.instance.add(new_tag)
-                lookup(name)
-              end.compact
+              new_tag = org.openhab.core.semantics.SemanticTagImpl.new("#{parent.uid}_#{name}",
+                                                                       label,
+                                                                       description,
+                                                                       synonyms)
+              Provider.instance.add(new_tag)
+              lookup(name)
             end
+          end
 
-            #
-            # Removes custom semantic tags.
-            #
-            # @param [SemanticTag, String, Symbol] tags Custom Semantic Tags to remove.
-            #   The built in Semantic Tags cannot be removed.
-            # @param [true, false] recursive Remove all children of the given tags.
-            #
-            # @return [Array<SemanticTag>] An array of tags successfully removed.
-            # @raise [ArgumentError] if any of the tags have children
-            # @raise [FrozenError] if any of the tags are not custom tags
-            #
-            # @since openHAB 4.0
-            #
-            def remove(*tags, recursive: false)
-              tags.flat_map do |tag|
-                tag = lookup(tag) unless tag.is_a?(SemanticTag)
-                next unless tag
-
-                provider = Provider.registry.provider_for(tag)
-                unless provider.is_a?(ManagedProvider)
-                  raise FrozenError, "Cannot remove item #{tag} from non-managed provider #{provider.inspect}"
-                end
+          #
+          # Removes custom semantic tags.
+          #
+          # @param [SemanticTag, String, Symbol] tags Custom Semantic Tags to remove.
+          #   The built in Semantic Tags cannot be removed.
+          # @param [true, false] recursive Remove all children of the given tags.
+          #
+          # @return [Array<SemanticTag>] An array of tags successfully removed.
+          # @raise [ArgumentError] if any of the tags have children
+          # @raise [FrozenError] if any of the tags are not custom tags
+          #
+          # @since openHAB 4.0
+          #
+          def remove(*tags, recursive: false)
+            tags.flat_map do |tag|
+              tag = lookup(tag) unless tag.is_a?(SemanticTag)
+              next unless tag
+
+              provider = Provider.registry.provider_for(tag)
+              unless provider.is_a?(ManagedProvider)
+                raise FrozenError, "Cannot remove item #{tag} from non-managed provider #{provider.inspect}"
+              end
 
-                children = []
-                Provider.registry.providers.grep(ManagedProvider).each do |managed_provider|
-                  managed_provider.all.each do |existing_tag|
-                    next unless existing_tag.parent_uid == tag.uid
-                    raise ArgumentError, "Cannot remove #{tag} because it has children" unless recursive
+              children = []
+              Provider.registry.providers.grep(ManagedProvider).each do |managed_provider|
+                managed_provider.all.each do |existing_tag|
+                  next unless existing_tag.parent_uid == tag.uid
+                  raise ArgumentError, "Cannot remove #{tag} because it has children" unless recursive
 
-                    children += remove(existing_tag, recursive: recursive)
-                  end
+                  children += remove(existing_tag, recursive:)
                 end
+              end
 
-                remove_const(tag.name) if provider.remove(tag.uid) && const_defined?(tag.name)
-                [tag] + children
-              end.compact
-            end
+              remove_const(tag.name) if provider.remove(tag.uid) && const_defined?(tag.name)
+              [tag] + children
+            end.compact
           end
         end
 

data/lib/openhab/core/items/switch_item.rb

@@ -50,7 +50,7 @@ module OpenHAB
         # @return [self]
         #
         def toggle(source: nil)
-          command!(!on?, source: source)
+          command!(!on?, source:)
         end
 
         # @!method on?

data/lib/openhab/core/items.rb

@@ -2,7 +2,7 @@
 
 require_relative "types"
 
-Dir[File.expand_path("items/*.rb", __dir__)].sort.each do |f|
+Dir[File.expand_path("items/*.rb", __dir__)].each do |f|
   require f
 end
 
@@ -64,35 +64,35 @@ module OpenHAB
               logger.trace { "Defining #{klass}/Enumerable##{command}/#{command}! for #{value}" }
 
               klass.class_eval <<~RUBY, __FILE__, __LINE__ + 1
-                ruby2_keywords def #{command}(*args, &block)   # ruby2_keywords def on(*args, &block)
-                  command(#{value}, *args, &block)             #   command(ON, *args, &block)
-                end                                            # end
-                                                               #
-                ruby2_keywords def #{command}!(*args, &block)  # ruby2_keywords def on!(*args, &block)
-                  command!(#{value}, *args, &block)            #   command!(ON, *args, &block)
-                end                                            # end
+                def #{command}(...)       # def on(...)
+                  command(#{value}, ...)  #   command(ON, ...)
+                end                       # end
+                                          #
+                def #{command}!(...)      # def on!(...)
+                  command!(#{value}, ...) #   command!(ON, ...)
+                end                       # end
               RUBY
 
               Enumerable.class_eval <<~RUBY, __FILE__, __LINE__ + 1
-                ruby2_keywords def #{command}(*args, &block)    # ruby2_keywords def on(*args, &block)
-                  each do |member|                              #   each do |member|
-                    member.#{command}(*args, &block)            #     member.on(*args, &block)
-                  end                                           #   end
-                end                                             # end
-                                                                #
-                ruby2_keywords def #{command}!(*args, &block)   # ruby2_keywords def on!(*args, &block)
-                  each do |member|                              #   each do |member|
-                    member.#{command}!(*args, &block)           #     member.on!(*args, &block)
-                  end                                           #   end
-                end                                             # end
+                def #{command}(...)         # def on(...)
+                  each do |member|          #   each do |member|
+                    member.#{command}(...)  #     member.on(...)
+                  end                       #   end
+                end                         # end
+                                            #
+                def #{command}!(...)        # def on!(...)
+                  each do |member|          #   each do |member|
+                    member.#{command}!(...) #     member.on!(...)
+                  end                       #   end
+                end                         # end
               RUBY
             else
               logger.trace { "Defining #{klass}/Enumerable##{command} for #{value}" }
 
               klass.class_eval <<~RUBY, __FILE__, __LINE__ + 1
-                ruby2_keywords def #{command}(*args, &block)  # ruby2_keywords def refresh(*args, &block)
-                  command!(#{value}, *args, &block)           #   command!(REFRESH, *args, &block)
-                end                                           # end
+                def #{command}(...)       # def refresh(...)
+                  command!(#{value}, ...) #   command!(REFRESH, ...)
+                end                       # end
               RUBY
 
               Enumerable.class_eval <<~RUBY, __FILE__, __LINE__ + 1

data/lib/openhab/core/lazy_array.rb

@@ -21,8 +21,8 @@ module OpenHAB
       # parameter. Returns self.
       #
       # If no block is given, an Enumerator is returned.
-      def each(&block)
-        to_a.each(&block)
+      def each(&)
+        to_a.each(&)
         self
       end
 
@@ -35,8 +35,8 @@ module OpenHAB
       end
 
       # Delegate any other methods to the actual array, exclude mutating methods
-      def method_missing(method, *args, &block)
-        return to_a.send(method, *args, &block) if method[-1] != "!" && Array.instance_methods.include?(method)
+      def method_missing(method, ...)
+        return to_a.send(method, ...) if method[-1] != "!" && Array.instance_methods.include?(method)
 
         super
       end