openhab-scripting 5.5.0 → 5.6.1

data/lib/openhab/core/items/metadata/hash.rb

@@ -22,53 +22,18 @@ module OpenHAB
           java_import org.openhab.core.items.Metadata
           private_constant :Metadata
 
-          include Enumerable
-
+          # Mutators are manually implemented below.
+          include EmulateHash
           extend Forwardable
-          def_delegators :@metadata, :configuration, :hash, :to_s, :uid, :value
-          private :configuration
 
-          # @!method to_hash
-          #   Implicit conversion to {::Hash}.
-          #   @return [::Hash]
-
-          # Make it act like a Hash; some methods can be handled by
-          # java.util.Map, others we have to convert to a Ruby Hash first, and
-          # still others (mutators) must be manually implemented below.
-          def_delegators :configuration,
-                         :any?,
-                         :compact,
-                         :compare_by_identity?,
-                         :deconstruct_keys,
-                         :default,
-                         :default_proc,
-                         :each,
-                         :each_key,
-                         :each_pair,
-                         :each_value,
-                         :empty?,
-                         :filter,
-                         :flatten,
-                         :has_value?,
-                         :invert,
-                         :key,
-                         :keys,
-                         :length,
-                         :rassoc,
-                         :reject,
-                         :select,
-                         :shift,
-                         :size,
-                         :to_a,
-                         :to_h,
-                         :to_hash,
-                         :transform_keys,
-                         :transform_values,
-                         :values,
-                         :value?
+          def_delegators :@metadata, :configuration, :hash, :uid, :value
+          private :configuration
 
           def_delegator :uid, :namespace
 
+          alias_method :to_map, :configuration
+          private :to_map
+
           class << self
             # @!visibility private
             def from_item(item_name, namespace, value)
@@ -209,48 +174,12 @@ module OpenHAB
           end
 
           # @!visibility private
-          def [](key)
-            configuration[key.to_s]
-          end
-
-          # @!visibility private
-          def []=(key, value)
+          def store(key, value)
             key = key.to_s
             new_config = to_h
             new_config[key] = value
             replace(new_config)
-            value # rubocop:disable Lint/Void
-          end
-          alias_method :store, :[]=
-
-          # @!visibility private
-          def assoc(key)
-            configuration.assoc(key.to_s)
-          end
-
-          # @!visibility private
-          def clear
-            replace({})
-          end
-
-          # @!visibility private
-          def compact!
-            replace(compact)
-          end
-
-          # @!visibility private
-          def compare_by_identity
-            raise NotImplementedError
-          end
-
-          # @!visibility private
-          def default=(*)
-            raise NotImplementedError
-          end
-
-          # @!visibility private
-          def default_proc=(*)
-            raise NotImplementedError
+            value
           end
 
           # @!visibility private
@@ -264,67 +193,6 @@ module OpenHAB
             old_value
           end
 
-          # @!visibility private
-          def delete_if(&block)
-            raise NotImplementedError unless block
-
-            replace(to_h.delete_if(block))
-          end
-
-          # @!visibility private
-          def dig(key, *keys)
-            configuration.dig(key.to_s, *keys)
-          end
-
-          # @!visibility private
-          def except(*keys)
-            to_h.except(*keys.map(&:to_s))
-          end
-
-          # @!visibility private
-          def fetch(key, &block)
-            configuration.fetch(key.to_s, &block)
-          end
-
-          # @!visibility private
-          def fetch_values(*keys, &block)
-            configuration.fetch_values(*keys.map(&:to_s), &block)
-          end
-
-          # @!visibility private
-          def keep_if(&block)
-            select!(&block)
-            self
-          end
-
-          # @!visibility private
-          def key?(key)
-            configuration.key?(key.to_s)
-          end
-          alias_method :include?, :key?
-          alias_method :has_key?, :key?
-          alias_method :member?, :key?
-
-          # @!visibility private
-          def merge!(*others, &block)
-            return self if others.empty?
-
-            new_config = to_h
-            others.each do |h|
-              new_config.merge!(h.transform_keys(&:to_s), &block)
-            end
-            replace(new_config)
-          end
-          alias_method :update, :merge!
-
-          # @!visibility private
-          def reject!(&block)
-            raise NotImplementedError unless block
-
-            r = to_h.reject!(&block)
-            replace(r) if r
-          end
-
           #
           # Replace the configuration with a new {::Hash}.
           #
@@ -337,42 +205,6 @@ module OpenHAB
             self
           end
 
-          # @!visibility private
-          def select!(&block)
-            raise NotImplementedError unless block?
-
-            r = to_h.select!(&block)
-            replace(r) if r
-          end
-          alias_method :filter!, :select!
-
-          # @!visibility private
-          def slice(*keys)
-            configuration.slice(*keys.map(&:to_s))
-          end
-
-          # @!visibility private
-          def to_proc
-            ->(k) { self[k] }
-          end
-
-          # @!visibility private
-          def transform_keys!(*args, &block)
-            replace(transform_keys(*args, &block))
-          end
-
-          # @!visibility private
-          def transform_values!(&block)
-            raise NotImplementedError unless block
-
-            replace(transform_values(&block))
-          end
-
-          # @!visibility private
-          def values_at(*keys)
-            configuration.values_at(*keys.map(&:to_s))
-          end
-
           # @!visibility private
           def inspect
             return to_h.inspect if value.empty?
@@ -380,8 +212,6 @@ module OpenHAB
 
             [value, to_h].inspect
           end
-          remove_method :to_s
-          alias_method :to_s, :inspect
 
           #
           # @raise [FrozenError] if the provider is not a

data/lib/openhab/core/items/metadata/namespace_hash.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "forwardable"
+
 module OpenHAB
   module Core
     module Items
@@ -16,6 +18,9 @@ module OpenHAB
         # All keys are converted to strings.
         #
         class NamespaceHash
+          include EmulateHash
+          extend Forwardable
+
           class << self
             #
             # @return [org.openhab.core.items.MetadataRegistry]
@@ -29,27 +34,6 @@ module OpenHAB
           java_import org.openhab.core.items.MetadataKey
           private_constant :MetadataKey
 
-          include Enumerable
-          extend Forwardable
-
-          def_delegators :to_hash,
-                         :<,
-                         :<=,
-                         :==,
-                         :>,
-                         :>=,
-                         :filter,
-                         :flatten,
-                         :invert,
-                         :key,
-                         :merge,
-                         :rassoc,
-                         :reject,
-                         :select,
-                         :to_a,
-                         :transform_keys,
-                         :transform_values
-
           def_delegators :keys,
                          :length,
                          :size
@@ -76,12 +60,29 @@ module OpenHAB
           def to_hash
             each.to_h { |namespace, meta| [namespace, meta] }
           end
+          alias_method :to_h, :to_hash
+          alias_method :to_map, :to_hash
+          private :to_map
 
-          # @return [Hash, nil]
-          #
           # @!visibility private
-          def [](namespace)
-            fetch(namespace, nil)
+          def fetch(key, *default_value, &block)
+            key = key.to_s
+            return @hash.fetch(key, *default_value, &block) unless attached?
+
+            if default_value.length > 1
+              raise ArgumentError, "Wrong number of arguments (given #{default_value.length + 1}, expected 1..2)"
+            end
+
+            logger.trace("Getting metadata for item: #{@item_name}, namespace '#{key}'")
+            if (m = Provider.registry.get(MetadataKey.new(key, @item_name)))
+              Hash.new(m)
+            elsif block
+              yield key
+            elsif !default_value.empty?
+              default_value.first
+            else
+              raise KeyError, "Key not found #{key.inspect}"
+            end
           end
 
           #
@@ -92,18 +93,12 @@ module OpenHAB
           # @return [Hash]
           #
           # @!visibility private
-          def []=(namespace, value)
+          def store(namespace, value)
             metadata = Hash.from_item(@item_name, namespace, value)
-            return @hash[metadata.uid.namespace] = metadata unless attached? # rubocop:disable Lint/ReturnInVoidContext
+            return @hash[metadata.uid.namespace] = metadata unless attached?
 
             metadata.create_or_update
-            metadata # rubocop:disable Lint/Void
-          end
-          alias_method :store, :[]=
-
-          # @!visibility private
-          def assoc(key)
-            to_hash.assoc(key.to_s)
+            metadata
           end
 
           #
@@ -133,41 +128,11 @@ module OpenHAB
             self
           end
 
-          # @!visibility private
-          def compare_by_identity
-            raise NotImplementedError
-          end
-
-          # @!visibility private
-          def compare_by_identity?
-            false
-          end
-
           # @!visibility private
           def deconstruct_keys
             self
           end
 
-          # @!visibility private
-          def default(*)
-            nil
-          end
-
-          # @!visibility private
-          def default=(*)
-            raise NotImplementedError
-          end
-
-          # @!visibility private
-          def default_proc
-            nil
-          end
-
-          # @!visibility private
-          def default_proc=(*)
-            raise NotImplementedError
-          end
-
           # @!visibility private
           def delete(namespace, &block)
             return @hash.delete(namespace.to_s, &block) unless attached?
@@ -249,33 +214,6 @@ module OpenHAB
             true
           end
 
-          # @!visibility private
-          def except(*keys)
-            to_hash.except(*keys.map(&:to_s))
-          end
-
-          # @!visibility private
-          def fetch(key, *default_value, &block)
-            key = key.to_s
-            return @hash.fetch(key, *default_value, &block) unless attached?
-
-            if default_value.length > 1
-              raise "wrong number of arguments (given #{default_value.length + 1}, expected 1..2)",
-                    ArgumentError
-            end
-
-            logger.trace("Getting metadata for item: #{@item_name}, namespace '#{key}'")
-            if (m = Provider.registry.get(MetadataKey.new(key, @item_name)))
-              Hash.new(m)
-            elsif block
-              yield key
-            elsif !default_value.empty?
-              default_value.first
-            else
-              raise "key not found #{key.inspect}", KeyError
-            end
-          end
-
           # @!visibility private
           def fetch_values(*keys)
             return @hash.fetch_values(keys.map(&:to_s)) if attached?
@@ -295,12 +233,6 @@ module OpenHAB
             ["metadata_namespace_hash", @item_name.hash]
           end
 
-          # @!visibility private
-          def keep_if(&block)
-            select!(&block)
-            self
-          end
-
           #
           # @return [true,false] True if the given namespace exists, false otherwise
           #
@@ -311,9 +243,7 @@ module OpenHAB
 
             !Provider.registry.get(MetadataKey.new(key, @item_name)).nil?
           end
-          alias_method :has_key?, :key?
           alias_method :member?, :key?
-          alias_method :include?, :key?
 
           # @!visibility private
           def keys
@@ -324,28 +254,16 @@ module OpenHAB
             each_key.to_a
           end
 
-          #
-          # Merge the given hash with the current metadata. Existing namespace that matches the name
-          # of the new namespace will be overwritten. Others will be added.
-          #
           # @!visibility private
-          def merge!(*others)
-            return self if others.empty?
-
-            others.each do |other|
-              case other
-              when ::Hash, NamespaceHash
-                other.each do |namespace, new_meta|
-                  self[namespace] = new_meta
-                  next unless block_given?
-
-                  current_meta = self[namespace]
-                  new_meta = yield key, current_meta, new_meta unless current_meta.nil?
-                  self[namespace] = new_meta unless new_meta.equal?(current_meta)
-                end
-              else
-                raise ArgumentError, "merge only supports Hash, or another item's metadata"
+          def replace(other)
+            clear
+            case other
+            when ::Hash, NamespaceHash
+              other.each do |namespace, new_meta|
+                self[namespace] = new_meta
               end
+            else
+              raise ArgumentError, "Only supports Hash, or another item's metadata. '#{other.class}' was given."
             end
             self
           end
@@ -381,8 +299,7 @@ module OpenHAB
             r = {}
             Provider.registry.all.each do |meta|
               if meta.uid.item_name == @item_name && keys.include?(meta.uid.namespace)
-                r[meta.uid.namespace] =
-                  Hash.new(meta)
+                r[meta.uid.namespace] = Hash.new(meta)
               end
             end
             r
@@ -404,17 +321,6 @@ module OpenHAB
             self
           end
 
-          # @!visibility private
-          def replace(other)
-            clear
-            merge!(other)
-          end
-
-          # @!visibility private
-          def to_proc
-            ->(k) { self[k] }
-          end
-
           # @!visibility private
           def transform_keys!(hash2 = nil)
             hash2 = hash2&.transform_keys(&:to_s)
@@ -459,15 +365,6 @@ module OpenHAB
           def values_at(*keys)
             keys.map(&self)
           end
-
-          #
-          # @return [String]
-          #
-          # @!visibility private
-          def inspect
-            to_hash.inspect
-          end
-          alias_method :to_s, :inspect
         end
       end
     end

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

@@ -93,6 +93,11 @@ module OpenHAB
               "synonyms=#{synonyms.to_a.inspect}>"
           end
 
+          # @return [String]
+          def to_s
+            name
+          end
+
           private
 
           def check_type(other)

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

@@ -13,6 +13,15 @@ module OpenHAB
           # @!visibility private
           java_import org.openhab.core.semantics.SemanticTags
 
+          #
+          # Returns the tag's string representation
+          #
+          # @return [String]
+          #
+          def to_s
+            java_class.simple_name
+          end
+
           #
           # Returns the tag's label
           #

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

@@ -176,6 +176,7 @@ module OpenHAB
         GenericItem.include(self)
         GroupItem.extend(Forwardable)
         GroupItem.def_delegators :members, :equipments, :locations
+
         # This is a marker interface for all semantic tag classes.
         # @interface
         # @deprecated Since openHAB 4.0, {SemanticTag} is the interface that all tags implement.
@@ -197,6 +198,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
@@ -306,7 +308,7 @@ module OpenHAB
                 raise ArgumentError, "Additional options can only be specified when creating one tag"
               end
 
-              synonyms = Array.wrap(synonyms).map(&:to_s).map(&:strip)
+              synonyms = Array.wrap(synonyms).map { |s| s.to_s.strip }
 
               tags.map do |name, parent|
                 # @deprecated OH4.0.0.M4 missing registry
@@ -315,7 +317,9 @@ module OpenHAB
                   next if lookup(name)
                   next unless parent
 
-                  new_tag = org.openhab.core.semantics.SemanticTagImpl.new("#{parent.uid}_#{name}", label, description,
+                  new_tag = org.openhab.core.semantics.SemanticTagImpl.new("#{parent.uid}_#{name}",
+                                                                           label,
+                                                                           description,
                                                                            synonyms)
                   Provider.instance.add(new_tag)
                   lookup(name)
@@ -328,7 +332,7 @@ module OpenHAB
                 end
               end.compact
             end
-        end
+          end
         end
 
         # @!parse

data/lib/openhab/core/rules/rule.rb

@@ -163,11 +163,24 @@ module OpenHAB
         # Manually trigger the rule
         #
         # @param [Object, nil] event The event to pass to the rule's execution blocks.
-        # @return [void]
-        #
-        def trigger(event = nil)
-          Rules.manager.run_now(uid, false, { "event" => event })
+        # @param [Boolean] consider_conditions Whether to check the conditions of the called rules.
+        # @param [kwargs] context The context to pass to the conditions and the actions of the rule.
+        # @return [Hash] A copy of the rule context, including possible return values.
+        #
+        def trigger(event = nil, consider_conditions: false, **context)
+          begin
+            event ||= org.openhab.core.automation.events.AutomationEventFactory
+                         .createExecutionEvent(uid, nil, "manual")
+          rescue NameError
+            # @deprecated OH3.4 doesn't have AutomationEventFactory
+          end
+          context.transform_keys!(&:to_s)
+          # Unwrap any proxies and pass raw objects (items, things)
+          context.transform_values! { |value| value.is_a?(Delegator) ? value.__getobj__ : value }
+          context["event"] = event if event # @deprecated OH3.4 - remove if guard. In OH4 `event` will never be nil
+          Rules.manager.run_now(uid, consider_conditions, context)
         end
+        alias_method :run, :trigger
       end
     end
   end

data/lib/openhab/core/things/links/provider.rb

@@ -25,7 +25,7 @@ module OpenHAB
 
             # @!visibility private
             def link(item, channel, config = {})
-              config = org.openhab.core.config.core.Configuration.new(config.transform_keys(&:to_s))
+              config = Configuration.new(config.transform_keys(&:to_s))
               channel = ChannelUID.new(channel) if channel.is_a?(String)
               channel = channel.uid if channel.is_a?(Channel)
               link = org.openhab.core.thing.link.ItemChannelLink.new(item.name, channel, config)

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

@@ -13,7 +13,8 @@ module OpenHAB
         def_delegators :__getobj__, :class, :is_a?, :kind_of?
 
         # @!visibility private
-        EVENTS = [Events::ThingAddedEvent::TYPE, Events::ThingUpdatedEvent::TYPE,
+        EVENTS = [Events::ThingAddedEvent::TYPE,
+                  Events::ThingUpdatedEvent::TYPE,
                   Events::ThingRemovedEvent::TYPE].freeze
         # @!visibility private
         UID_METHOD = :uid

data/lib/openhab/core/things/thing.rb

@@ -37,6 +37,29 @@ module OpenHAB
       # @!attribute [r] channels
       #   @return [ChannelArray]
       #
+      # @!attribute [r] uid
+      #   Return the UID.
+      #   @return [org.openhab.core.thing.ThingUID]
+      #
+      # @!attribute [r] bridge_uid
+      #   Return the Bridge UID when available.
+      #   @return [org.openhab.core.thing.ThingUID]
+      #
+      # @!attribute [r] configuration
+      #   Return the thing's configuration.
+      #   @return [OpenHAB::Core::Configuration]
+      #
+      #   @example
+      #     logger.info things["smtp:mail:local"].configuration["hostname"]
+      #     logger.info things["ipcamera:dahua:frontporch"].configuration["ipAddress"]
+      #
+      # @!attribute [r] properties
+      #   Return the properties when available.
+      #   @return [Hash]
+      #
+      #   @example
+      #     logger.info things["fronius:meter:mybridge:mymeter"].properties["modelId"]
+      #
       module Thing
         # Array wrapper class to allow searching a list of channels
         # by channel id

data/lib/openhab/core/types/date_time_type.rb

@@ -144,7 +144,8 @@ module OpenHAB
         def coerce(other)
           logger.trace("Coercing #{self} as a request from #{other.class}")
           return [other, zoned_date_time] if other.respond_to?(:to_zoned_date_time)
-          return [DateTimeType.new(other), self] if other.respond_to?(:to_time)
+
+          [DateTimeType.new(other), self] if other.respond_to?(:to_time)
         end
 
         #

data/lib/openhab/core/types/open_closed_type.rb

@@ -28,7 +28,8 @@ module OpenHAB
         # @return [OpenClosedType] {OPEN} if {closed?}, {CLOSED} if {open?}
         def !
           return CLOSED if open?
-          return OPEN if closed?
+
+          OPEN if closed?
         end
       end
     end

data/lib/openhab/core/types/string_type.rb

@@ -63,7 +63,7 @@ module OpenHAB
         #
         def coerce(other)
           logger.trace("Coercing #{self} as a request from #{other.class}")
-          return [other.to_str, self] if other.respond_to?(:to_str)
+          [other.to_str, self] if other.respond_to?(:to_str)
         end
 
         # any method that exists on String gets forwarded to to_s