openhab-scripting 4.43.1 → 4.44.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: deaecd8879b238c5372c733482c69ef38703231f42a8869954d692ebd3c4fc7b
-  data.tar.gz: d11b35e9b654531f1c248992cb1cd2eca1e675dd37898ca28ce16760a1531c07
+  metadata.gz: '091c2e6fd32317b8976246f8f69332c793e9ef3d3bfc1991e9b9065716e6e668'
+  data.tar.gz: adfc88ad7a7bcd999bdd49c104efb395cda2b9dd1c27bf439a941700840e7457
 SHA512:
-  metadata.gz: 3052e39904c2548942c1018b592ca3370b3c15bdd1dc92685ee647f9854bcc406b886f1168b75954adab98884a45c9a92a7eb039a13056be5f4a99772111e425
-  data.tar.gz: 752cd312e184091663ea4c47506787fdd6ea9e56b1a794593c093b413784340bbb97c95956e716762757b355a6089e45cb96dbe2d61b6787f98641bbde557e75
+  metadata.gz: fef562627789d792db873720ef7e13f0c5264e1c091f943ee4fc15c0313cd5037722271195afb9506359a7a3d5e4fa133940a8e38ccaa59d183c5c4233f0464a
+  data.tar.gz: 919b481338f0db3a842024f8fabed9493233430e310bd3453a388731350c2a033b4d8f4d6902a28cbe527db8c398bc8cfa705f045d85dfe943e7e353353622fb

data/lib/openhab/core/entity_lookup.rb

@@ -73,9 +73,7 @@ module OpenHAB
         return if name.count('_') < 3
 
         name = name.tr('_', ':')
-        # rubocop: disable Style/GlobalVars
-        $things.get(Java::OrgOpenhabCoreThing::ThingUID.new(name))
-        # rubocop: enable Style/GlobalVars
+        $things.get(org.openhab.core.thing.ThingUID.new(name))
       end
 
       #
@@ -88,7 +86,7 @@ module OpenHAB
       def self.lookup_item(name)
         logger.trace("Looking up item(#{name})")
         name = name.to_s if name.is_a? Symbol
-        item = $ir.get(name) # rubocop: disable Style/GlobalVars
+        item = $ir.get(name)
         ItemProxy.new(item) unless item.nil?
       end
     end

data/lib/openhab/core/item_proxy.rb

@@ -22,7 +22,7 @@ module OpenHAB
       # Lookup item from item registry
       #
       def __getobj__
-        $ir.get(@item_name) # rubocop:disable Style/GlobalVars
+        $ir.get(@item_name)
       end
     end
   end

data/lib/openhab/core/osgi.rb

@@ -50,9 +50,7 @@ module OpenHAB
 
       # Get the OSGI Bundle for ScriptExtension Class
       def self.bundle
-        # rubocop: disable Style/GlobalVars
         @bundle ||= FrameworkUtil.getBundle($scriptExtension.class)
-        # rubocop: enable Style/GlobalVars
       end
       private_class_method :bundle
     end

data/lib/openhab/core/services.rb

@@ -11,7 +11,6 @@ module OpenHAB
 
     # Get the OpenHAB automation manager
     # @return [AutomationManager] OpenHAB Automation manager
-    # rubocop:disable Style/GlobalVars
     def self.automation_manager
       $scriptExtension.get('automationManager')
     end
@@ -21,6 +20,5 @@ module OpenHAB
     def self.rule_registry
       $scriptExtension.get('ruleRegistry')
     end
-    # rubocop:enable Style/GlobalVars
   end
 end

data/lib/openhab/dsl/actions.rb

@@ -29,23 +29,19 @@ module OpenHAB
       # @return [Object] OpenHAB action
       #
       def actions(scope, thing_uid)
-        # rubocop: disable Style/GlobalVars
         $actions.get(scope, thing_uid)
-        # rubocop: enable Style/GlobalVars
       end
 
       #
       # Gets the list of action objects associated with a specific ThingUID
       #
-      # @param [Java::org::openhab::core::thing::ThingUID] thing_uid to get associated actions for
+      # @param [org.openhab.core.thing.ThingUID] thing_uid to get associated actions for
       #
       # @return [Array] of action objects associated with thing_uid, may be empty
       #
       def actions_for_thing(thing_uid)
         thing_uid = thing_uid.to_s
-        # rubocop: disable Style/GlobalVars
         action_keys = $actions.action_keys
-        # rubocop: enable Style/GlobalVars
         logger.trace("Registered actions: '#{action_keys}' for thing '#{thing_uid}'")
         action_keys.map { |action_key| action_key.split('-', 2) }
                    .select { |action_pair| action_pair.last == thing_uid }

data/lib/openhab/dsl/group.rb

@@ -46,7 +46,7 @@ module OpenHAB
 
         # explicit conversion to array
         def to_a
-          $ir.items.grep(org.openhab.core.items.GroupItem) # rubocop:disable Style/GlobalVars
+          $ir.items.grep(org.openhab.core.items.GroupItem)
         end
       end
     end

data/lib/openhab/dsl/items/item_registry.rb

@@ -39,14 +39,14 @@ module OpenHAB
         # @param name [String] Item name to check
         # @return [Boolean] true if the item exists, false otherwise
         def include?(name)
-          !$ir.getItems(name).empty? # rubocop: disable Style/GlobalVars
+          !$ir.getItems(name).empty?
         end
         alias key? include?
 
         # Explicit conversion to array
         # @return [Array]
         def to_a
-          $ir.items.to_a # rubocop:disable Style/GlobalVars
+          $ir.items.to_a
         end
       end
     end

data/lib/openhab/dsl/items/metadata.rb

@@ -14,8 +14,8 @@ module OpenHAB
       module Metadata
         include OpenHAB::Log
 
-        java_import Java::OrgOpenhabCoreItems::Metadata
-        java_import Java::OrgOpenhabCoreItems::MetadataKey
+        java_import org.openhab.core.items.Metadata
+        java_import org.openhab.core.items.MetadataKey
 
         #
         # Provide the interface to access namespace's value and configuration
@@ -43,7 +43,7 @@ module OpenHAB
           #
           # Delete the configuration with the given key
           #
-          # @return [Java::Org::openhab::core::items::Metadata] the old metadata
+          # @return [org.openhab.core.items.Metadata] the old metadata
           #
           def delete(key)
             configuration = {}.merge(@metadata&.configuration || {})
@@ -55,7 +55,7 @@ module OpenHAB
           #
           # Set the metadata value
           #
-          # @return [Java::Org::openhab::core::items::Metadata] the old metadata
+          # @return [org.openhab.core.items.Metadata] the old metadata
           #
           def value=(value)
             metadata = Metadata.new(@metadata&.uID, value&.to_s, @metadata&.configuration)
@@ -65,7 +65,7 @@ module OpenHAB
           #
           # Set the entire configuration to a hash
           #
-          # @return [Java::Org::openhab::core::items::Metadata] the old metadata
+          # @return [org.openhab.core.items.Metadata] the old metadata
           #
           def config=(config)
             config = config.to_hash if config.respond_to?(:to_hash)
@@ -114,8 +114,8 @@ module OpenHAB
           # Convert the given object to Ruby equivalent
           def self.to_ruby(value)
             case value
-            when Hash, Java::JavaUtil::Map then to_ruby_hash(value)
-            when Array, Java::JavaUtil::List then to_ruby_array(value)
+            when Hash, java.util.Map then to_ruby_hash(value)
+            when Array, java.util.List then to_ruby_array(value)
             when String then String.new(value)
             else value
             end
@@ -147,7 +147,7 @@ module OpenHAB
           # Set the metadata namespace. If the namespace does not exist, it will be created
           #
           # @param value [Object] The assigned value can be a OpenHAB::DSL::Items::MetadataItem,
-          # Java::Org::openhab::core::items::Metadata, Array[2] of [value, configuration],
+          # org.openhab.core.items.Metadata, Array[2] of [value, configuration],
           # A String to set the value and clear the configuration,
           # or a Hash to set the configuration and set the value to nil
           #
@@ -246,7 +246,7 @@ module OpenHAB
           end
 
           #
-          # @return [Java::org::openhab::core::items::MetadataRegistry]
+          # @return [org.openhab.core.items.MetadataRegistry]
           #
           def self.registry
             @registry ||= OpenHAB::Core::OSGI.service('org.openhab.core.items.MetadataRegistry')

data/lib/openhab/dsl/items/persistence.rb

@@ -10,7 +10,7 @@ module OpenHAB
       #       When given a positive Duration, the timestamp will be calculated as ++now-Duration++
       #
       module Persistence
-        java_import Java::OrgOpenhabCoreTypesUtil::UnitUtils
+        java_import org.openhab.core.types.util.UnitUtils
 
         # A state class with an added timestamp attribute. This is used to hold OpenHAB's HistoricItem.
         class HistoricState < SimpleDelegator
@@ -253,7 +253,7 @@ module OpenHAB
         # @return [ZonedDateTime]
         #
         def to_zdt(timestamp)
-          timestamp = timestamp.negated if timestamp.is_a? Java::JavaTime::Duration
+          timestamp = timestamp.negated if timestamp.is_a? java.time.Duration
           OpenHAB::DSL.to_zdt(timestamp)
         end
 

data/lib/openhab/dsl/items/timed_command.rb

@@ -177,10 +177,8 @@ module OpenHAB
                   logger.trace "Canceling implicit timer #{@timed_command_details.timer} for "\
                                "#{@timed_command_details.item.id}  because received event #{inputs}"
                   @timed_command_details.timer.cancel
-                  # rubocop: disable Style/GlobalVars
                   # Disabled due to OpenHAB design
                   $scriptExtension.get('ruleRegistry').remove(@timed_command_details.rule_uid)
-                  # rubocop: enable Style/GlobalVars
                   TimedCommand.timed_commands.delete(@timed_command_details.item)
                   if @block
                     logger.trace 'Executing user supplied block on timed command cancelation'

data/lib/openhab/dsl/monkey_patch/actions/script_thing_actions.rb

@@ -9,10 +9,19 @@ module OpenHAB
       # Patches OpenHAB actions
       #
       module Actions
+        begin
+          # openHAB 3.3 uses ScriptThingActionsImpl
+          java_import Java::OrgOpenhabCoreAutomationModuleScriptInternalDefaultscope::ScriptThingActionsImpl
+        rescue NameError
+          # openHAB 3.2 uses ScriptThingActions
+          java_import Java::OrgOpenhabCoreAutomationModuleScriptInternalDefaultscope::ScriptThingActions
+          ScriptThingActionsImpl = ScriptThingActions
+        end
+
         #
         # MonkeyPatching ScriptThingActions
         #
-        class << $actions # rubocop:disable Style/GlobalVars
+        class ScriptThingActionsImpl
           field_reader :THING_ACTIONS_MAP
 
           #

data/lib/openhab/dsl/monkey_patch/events/thing_status_info.rb

@@ -9,8 +9,8 @@ module OpenHAB
       # Patches OpenHAB events
       #
       module Event
-        java_import Java::OrgOpenhabCoreThingEvents::ThingStatusInfoChangedEvent
-        java_import Java::OrgOpenhabCoreThingEvents::ThingStatusInfoEvent
+        java_import org.openhab.core.thing.events.ThingStatusInfoChangedEvent
+        java_import org.openhab.core.thing.events.ThingStatusInfoEvent
         #
         # Monkey patch with ruby style accessors
         #

data/lib/openhab/dsl/monkey_patch/ruby/number.rb

@@ -11,7 +11,7 @@ module OpenHAB
           #
           # Create Duration with the specified unit
           #
-          # @return [Java::JavaTime::Duration] Duration with number of units from self
+          # @return [java.time.Duration] Duration with number of units from self
           #
           %w[millis seconds minutes hours].each do |unit|
             define_method(unit) { java.time.Duration.public_send("of_#{unit}", self) }
@@ -32,7 +32,7 @@ module OpenHAB
           #
           # Create Duration with number of milliseconds
           #
-          # @return [Java::JavaTime::Duration] Duration truncated to an integral number of milliseconds from self
+          # @return [java.time.Duration] Duration truncated to an integral number of milliseconds from self
           #
           def millis
             java.time.Duration.of_millis(to_i)
@@ -41,7 +41,7 @@ module OpenHAB
           #
           # Create Duration with number of seconds
           #
-          # @return [Java::JavaTime::Duration] Duration with number of seconds from self
+          # @return [java.time.Duration] Duration with number of seconds from self
           #
           def seconds
             (self * 1000).millis
@@ -50,7 +50,7 @@ module OpenHAB
           #
           # Create Duration with number of minutes
           #
-          # @return [Java::JavaTime::Duration] Duration with number of minutes from self
+          # @return [java.time.Duration] Duration with number of minutes from self
           #
           def minutes
             (self * 60).seconds
@@ -59,7 +59,7 @@ module OpenHAB
           #
           # Create Duration with number of hours
           #
-          # @return [Java::JavaTime::Duration] Duration with number of hours from self
+          # @return [java.time.Duration] Duration with number of hours from self
           #
           def hours
             (self * 60).minutes

data/lib/openhab/dsl/rules/automation_rule.rb

@@ -37,6 +37,7 @@ module OpenHAB
           super()
           set_name(config.name)
           set_description(config.description)
+          set_tags(to_string_set(config.tags))
           set_triggers(config.triggers)
           self.uid = config.uid
           @run_context = config.caller
@@ -263,6 +264,28 @@ module OpenHAB
           @run_context.instance_exec(event, &task.block)
         end
 
+        #
+        # Convert the given array to a set of strings.
+        # Convert Semantics classes to their simple name
+        #
+        # @example
+        #   to_string_set("tag1", Semantics::LivingRoom)
+        #
+        # @param [Array] *tags An array of strings or Semantics classes
+        #
+        # @return [Set] A set of strings
+        #
+        def to_string_set(*tags)
+          tags = tags.flatten.map do |tag|
+            if tag.respond_to?(:java_class) && tag < org.openhab.core.semantics.Tag
+              tag.java_class.simple_name
+            else
+              tag.to_s
+            end
+          end
+          Set.new(tags)
+        end
+
         #
         # Create a new hash in which all elements are converted to strings
         #

data/lib/openhab/dsl/rules/name_inference.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module DSL
+    module Rules
+      # Contains helper methods for inferring a rule name from its triggers
+      module NameInference
+        # Trigger Type UIDs that we know how to generate a name for
+        KNOWN_TRIGGER_TYPES = [
+          'core.ChannelEventTrigger',
+          'core.GroupCommandTrigger',
+          'core.GroupStateChangeTrigger',
+          'core.GroupStateUpdateTrigger',
+          'core.ItemCommandTrigger',
+          'core.ItemStateChangeTrigger',
+          'core.ItemStateUpdateTrigger',
+          Triggers::Cron::CRON_TRIGGER_MODULE_ID
+        ].freeze
+        private_constant :KNOWN_TRIGGER_TYPES
+
+        class << self
+          # get the block's source location, and simplify to a simple filename
+          def infer_rule_id_from_block(block)
+            file = File.basename(block.source_location.first)
+            "#{file}:#{block.source_location.last}"
+          end
+
+          # formulate a readable rule name such as "TestSwitch received command ON" if possible
+          def infer_rule_name(config) # rubocop:disable Metrics
+            known_triggers, unknown_triggers = config.triggers.partition do |t|
+              KNOWN_TRIGGER_TYPES.include?(t.type_uid)
+            end
+            return nil unless unknown_triggers.empty?
+
+            cron_triggers = known_triggers.select { |t| t.type_uid == 'jsr223.jruby.CronTrigger' }
+            ruby_every_triggers = config.ruby_triggers.select { |t| t.first == :every }
+
+            # makes sure there aren't any true cron triggers cause we can't format them
+            return nil unless cron_triggers.length == ruby_every_triggers.length
+            return nil unless config.ruby_triggers.length == 1
+
+            infer_rule_name_from_trigger(*config.ruby_triggers.first)
+          end
+
+          private
+
+          # formulate a readable rule name from a single trigger if possible
+          def infer_rule_name_from_trigger(trigger, items, kwargs)
+            case trigger
+            when :every
+              infer_rule_name_from_every_trigger(items, **kwargs)
+            when :channel
+              infer_rule_name_from_channel_trigger(items, **kwargs)
+            when :changed, :updated, :received_command
+              infer_rule_name_from_item_trigger(trigger, items, kwargs)
+            end
+          end
+
+          # formulate a readable rule name from an item-type trigger
+          def infer_rule_name_from_item_trigger(trigger, items, kwargs) # rubocop:disable Metrics
+            kwargs.delete(:command) if kwargs[:command] == [nil]
+            return unless items.length <= 3 &&
+                          (kwargs.keys - %i[from to command duration]).empty?
+            return if kwargs.values_at(:from, :to, :command).compact.any? do |v|
+              next false if v.is_a?(Array) && v.length <= 4 # arbitrary length
+              next false if v.is_a?(Range)
+
+              v.is_a?(Proc) || v.is_a?(Enumerable)
+            end
+
+            trigger_name = trigger.to_s.tr('_', ' ')
+            item_names = items.map do |item|
+              if item.is_a?(GroupItem::GroupMembers)
+                "#{item.group.name}.members"
+              else
+                item.name
+              end
+            end
+            name = "#{format_beginning_of_sentence_array(item_names)} #{trigger_name}"
+
+            name += " from #{format_inspected_array(kwargs[:from])}" if kwargs[:from]
+            name += " to #{format_inspected_array(kwargs[:to])}" if kwargs[:to]
+            name += " #{format_inspected_array(kwargs[:command])}" if kwargs[:command]
+            name += " for #{kwargs[:duration]}" if kwargs[:duration]
+            name.freeze
+          end
+
+          # formulate a readable rule name from an every-style cron trigger
+          def infer_rule_name_from_every_trigger(value, at:)
+            name = "Every #{value}"
+            name += " at #{at}" if at
+            name
+          end
+
+          # formulate a readable rule name from a channel trigger
+          def infer_rule_name_from_channel_trigger(channels, triggers:)
+            triggers = [] if triggers == [nil]
+            name = "#{format_beginning_of_sentence_array(channels)} triggered"
+            name += " #{format_inspected_array(triggers)}" unless triggers.empty?
+            name
+          end
+
+          # format an array of words that will be the beginning of a sentence
+          def format_beginning_of_sentence_array(array)
+            result = format_array(array)
+            if array.length > 2
+              result = result.dup
+              result[0] = 'A'
+              result.freeze
+            end
+            result
+          end
+
+          # format an array of items that need to be inspected individually
+          def format_inspected_array(array)
+            return array.inspect if array.is_a?(Range)
+
+            array = [array] unless array.is_a?(Array)
+            format_array(array.map(&:inspect))
+          end
+
+          # format an array of words in a friendly way
+          def format_array(array)
+            return array[0] if array.length == 1
+            return "#{array[0]} or #{array[1]}" if array.length == 2
+
+            "any of #{array.join(', ')}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -8,6 +8,7 @@ require 'openhab/log/logger'
 require_relative 'rule_config'
 require_relative 'automation_rule'
 require_relative 'guard'
+require_relative 'name_inference'
 
 module OpenHAB
   #
@@ -34,32 +35,30 @@ module OpenHAB
 
         module_function
 
-        # get the block's source location, and simplify to a simple filename
-        def self.infer_rule_id_from_block(block)
-          file = File.basename(block.source_location.first)
-          "#{file}:#{block.source_location.last}"
-        end
-
         #
         # Create a new rule
         #
-        # @param [String] rule_name <description>
+        # @param [String] rule_name The rule name
         # @yield [] Block executed in context of a RuleConfig
         #
         #
         def rule(rule_name = nil, id: nil, script: nil, &block) # rubocop:disable Metrics
-          id ||= Rule.infer_rule_id_from_block(block)
-          rule_name ||= id
+          id ||= NameInference.infer_rule_id_from_block(block)
           script ||= block.source rescue nil # rubocop:disable Style/RescueModifier
 
           OpenHAB::Core::ThreadLocal.thread_local(RULE_NAME: rule_name) do
             @rule_name = rule_name
 
-            config = RuleConfig.new(rule_name, block.binding)
+            config = RuleConfig.new(block.binding)
             config.uid(id)
             config.instance_exec(config, &block)
             config.guard = Guard::Guard.new(run_context: config.caller, only_if: config.only_if,
                                             not_if: config.not_if)
+
+            rule_name ||= NameInference.infer_rule_name(config)
+            rule_name ||= id
+
+            config.name(rule_name)
             logger.trace { config.inspect }
             process_rule_config(config, script)
           end
@@ -89,7 +88,7 @@ module OpenHAB
           rule = AutomationRule.new(config: config)
           Rule.script_rules << rule
           added_rule = add_rule(rule)
-          added_rule.actions.first.id = 'script'
+          # add config so that MainUI can show the script
           added_rule.actions.first.configuration.put('type', 'application/x-ruby')
           added_rule.actions.first.configuration.put('script', script)
 
@@ -142,13 +141,13 @@ module OpenHAB
         #
         # Add a rule to the automation managed
         #
-        # @param [Java::OrgOpenhabCoreAutomationModuleScriptRulesupportSharedSimple::SimpleRule] rule to add
+        # @param [org.openhab.core.automation.module.script.rulesupport.shared.simple.SimpleRule] rule to add
         #
         #
         def add_rule(rule)
           base_uid = rule.uid
           duplicate_index = 1
-          while $rules.get(rule.uid) # rubocop:disable Style/GlobalVars
+          while $rules.get(rule.uid)
             duplicate_index += 1
             rule.uid = "#{base_uid} (#{duplicate_index})"
           end

data/lib/openhab/dsl/rules/rule_config.rb

@@ -36,6 +36,9 @@ module OpenHAB
         # @return [Object] object that invoked rule method
         attr_accessor :caller
 
+        # @return [Array] Of trigger definitions as passed in Ruby
+        attr_reader :ruby_triggers
+
         #
         # Struct holding a run block
         #
@@ -64,6 +67,7 @@ module OpenHAB
         prop :uid
         prop :name
         prop :description
+        prop :tags
         prop :enabled
         prop :between
 
@@ -73,12 +77,13 @@ module OpenHAB
         # @param [Object] caller_binding The object initializing this configuration.
         #   Used to execute within the object's context
         #
-        def initialize(rule_name, caller_binding)
+        def initialize(caller_binding)
           @rule_triggers = RuleTriggers.new
           @caller = caller_binding.eval 'self'
-          name(rule_name)
+          @ruby_triggers = []
           enabled(true)
           on_start(false)
+          tags([])
         end
 
         #

data/lib/openhab/dsl/rules/terse.rb

@@ -7,10 +7,8 @@ module OpenHAB
       module TerseRule
         %i[changed channel cron every updated received_command].each do |trigger|
           class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-            def #{trigger}(*args, name: nil, **kwargs, &block)            # def changed(*args, name: nil, **kwargs, &block)
-              name ||= infer_rule_name(#{trigger.inspect}, args, kwargs)  #   name ||= infer_rule_name(:changed, args, kwargs)
-              id = Rule.infer_rule_id_from_block(block)                   #   id = Rule.infer_rule_id_from_block(block)
-              name ||= id                                                 #   name ||= id
+            def #{trigger}(*args, name: nil, id: nil, **kwargs, &block)   # def changed(*args, name: nil, id: nil, **kwargs, &block)
+              id ||= NameInference.infer_rule_id_from_block(block)        #   id ||= NameInference.infer_rule_id_from_block(block)
               script = block.source rescue nil                            #   script = block.source rescue nil
               rule name, id: id, script: script do                        #   rule name, id: id, script: script do
                 #{trigger}(*args, **kwargs)                               #     changed(*args, **kwargs)
@@ -20,31 +18,6 @@ module OpenHAB
             module_function #{trigger.inspect}                            # module_function :changed
           RUBY
         end
-
-        private
-
-        # formulate a readable rule name such as "TestSwitch received command ON" if possible
-        def infer_rule_name(trigger, args, kwargs) # rubocop:disable Metrics
-          return unless %i[changed updated received_command].include?(trigger) &&
-                        args.length == 1 &&
-                        (kwargs.keys - %i[from to command]).empty?
-          return if kwargs[:from].is_a?(Enumerable)
-          return if kwargs[:to].is_a?(Enumerable)
-          return if kwargs[:command].is_a?(Enumerable)
-
-          trigger_name = trigger.to_s.tr('_', ' ')
-          name = if args.first.is_a?(GroupItem::GroupMembers) # rubocop:disable Style/CaseLikeIf === doesn't work with GenericItem
-                   "#{args.first.group.name}.members #{trigger_name}"
-                 elsif args.first.is_a?(GenericItem)
-                   "#{args.first.name} #{trigger_name}"
-                 end
-          return unless name
-
-          name += " from #{kwargs[:from].inspect}" if kwargs[:from]
-          name += " to #{kwargs[:to].inspect}" if kwargs[:to]
-          name += " #{kwargs[:command].inspect}" if kwargs[:command]
-          name
-        end
       end
     end
   end

data/lib/openhab/dsl/rules/triggers/changed.rb

@@ -28,14 +28,16 @@ module OpenHAB
         #
         def changed(*items, to: nil, from: nil, for: nil, attach: nil)
           changed = Changed.new(rule_triggers: @rule_triggers)
-          Changed.flatten_items(items).map do |item|
-            logger.trace("Creating changed trigger for entity(#{item}), to(#{to}), from(#{from})")
+          # for is a reserved word in ruby, so use local_variable_get :for
+          duration = binding.local_variable_get(:for)
 
-            # for is a reserved word in ruby, so use local_variable_get :for
-            wait_duration = binding.local_variable_get(:for)
+          flattened_items = Changed.flatten_items(items)
+          @ruby_triggers << [:changed, flattened_items, { to: to, from: from, duration: duration }]
+          flattened_items.map do |item|
+            logger.trace("Creating changed trigger for entity(#{item}), to(#{to}), from(#{from})")
 
             Changed.each_state(from, to) do |from_state, to_state|
-              changed.trigger(item: item, from: from_state, to: to_state, duration: wait_duration, attach: attach)
+              changed.trigger(item: item, from: from_state, to: to_state, duration: duration, attach: attach)
             end
           end.flatten
         end

data/lib/openhab/dsl/rules/triggers/channel.rb

@@ -26,8 +26,11 @@ module OpenHAB
         #
         def channel(*channels, thing: nil, triggered: nil, attach: nil)
           channel_trigger = Channel.new(rule_triggers: @rule_triggers)
-          Channel.channels(channels: channels, thing: thing).each do |channel|
-            [triggered].flatten.each do |trigger|
+          flattened_channels = Channel.channels(channels: channels, thing: thing)
+          triggers = [triggered].flatten
+          @ruby_triggers << [:channel, flattened_channels, { triggers: triggers }]
+          flattened_channels.each do |channel|
+            triggers.each do |trigger|
               channel_trigger.trigger(channel: channel, trigger: trigger, attach: attach)
             end
           end

data/lib/openhab/dsl/rules/triggers/command.rb

@@ -28,8 +28,10 @@ module OpenHAB
 
           # Combine command and commands, doing union so only a single nil will be in the combined array.
           combined_commands = Command.combine_commands(command: command, commands: commands)
+          flattened_items = Command.flatten_items(items)
+          @ruby_triggers << [:received_command, flattened_items, { command: combined_commands }]
 
-          Command.flatten_items(items).map do |item|
+          flattened_items.map do |item|
             combined_commands.map do |cmd|
               logger.states 'Creating received command trigger', item: item, command: cmd
 

data/lib/openhab/dsl/rules/triggers/conditions/duration.rb

@@ -86,7 +86,7 @@ module OpenHAB
             #
             # Converts a ThingStatus object to a ruby Symbol
             #
-            # @param [Java::OrgOpenhabCoreThing::ThingStatus] status A ThingStatus instance
+            # @param [org.openhab.core.thing.ThingStatus] status A ThingStatus instance
             #
             # @return [Symbol] A corresponding symbol, in lower case
             #

data/lib/openhab/dsl/rules/triggers/cron/cron.rb

@@ -21,10 +21,12 @@ module OpenHAB
         def every(value, at: nil, attach: nil)
           return every(MonthDay.parse(value), at: at, attach: attach) if value.is_a? String
 
+          @ruby_triggers << [:every, value, { at: at }]
+
           cron_expression = case value
                             when Symbol then Cron.from_symbol(value, at)
-                            when Java::JavaTime::Duration then Cron.from_duration(value, at)
-                            when Java::JavaTime::MonthDay then Cron.from_monthday(value, at)
+                            when java.time.Duration then Cron.from_duration(value, at)
+                            when java.time.MonthDay then Cron.from_monthday(value, at)
                             else raise ArgumentError, 'Unknown interval'
                             end
           cron(cron_expression, attach: attach)
@@ -110,7 +112,7 @@ module OpenHAB
           #
           # Create a cron map from a duration
           #
-          # @param [Java::JavaTime::Duration] duration
+          # @param [java.time.Duration] duration
           # @param [Object] at TimeOfDay or String representing time of day
           #
           # @return [Hash] map describing cron expression
@@ -124,7 +126,7 @@ module OpenHAB
           #
           # Create a cron map from a MonthDay
           #
-          # @param [Java::JavaTime::MonthDay] monthday a {MonthDay} object
+          # @param [java.time.MonthDay] monthday a {MonthDay} object
           # @param [Object] at TimeOfDay or String representing time of day
           #
           # @return [Hash] map describing cron expression
@@ -176,7 +178,7 @@ module OpenHAB
           #
           # Convert a Java Duration to a map for the map_to_cron method
           #
-          # @param duration [Java::JavaTime::Duration] The duration object
+          # @param duration [java.time.Duration] The duration object
           #
           # @return [Hash] a map suitable for map_to_cron
           #

data/lib/openhab/dsl/rules/triggers/updated.rb

@@ -23,7 +23,9 @@ module OpenHAB
         #
         def updated(*items, to: nil, attach: nil)
           updated = Updated.new(rule_triggers: @rule_triggers)
-          Updated.flatten_items(items).map do |item|
+          flattened_items = Updated.flatten_items(items)
+          @ruby_triggers << [:updated, flattened_items, { to: to }]
+          flattened_items.map do |item|
             logger.trace("Creating updated trigger for item(#{item}) to(#{to})")
             [to].flatten.map do |to_state|
               updated.trigger(item: item, to: to_state, attach: attach)

data/lib/openhab/dsl/things.rb

@@ -108,7 +108,7 @@ module OpenHAB
         # @return Thing specified by name/UID or nil if name/UID does not exist in thing registry
         def [](uid)
           uid = generate_thing_uid(uid) unless uid.is_a?(org.openhab.core.thing.ThingUID)
-          thing = $things.get(uid) # rubocop: disable Style/GlobalVars
+          thing = $things.get(uid)
           return unless thing
 
           logger.trace("Retrieved Thing(#{thing}) from registry for uid: #{uid}")
@@ -119,7 +119,7 @@ module OpenHAB
 
         # explicit conversion to array
         def to_a
-          $things.getAll.map { |thing| Thing.new(thing) } # rubocop: disable Style/GlobalVars
+          $things.getAll.map { |thing| Thing.new(thing) }
         end
 
         private

data/lib/openhab/dsl/timers/timer.rb

@@ -103,7 +103,7 @@ module OpenHAB
       return unless timestamp
 
       case timestamp
-      when Java::JavaTimeTemporal::TemporalAmount then ZonedDateTime.now.plus(timestamp)
+      when java.time.temporal.TemporalAmount then ZonedDateTime.now.plus(timestamp)
       when ZonedDateTime then timestamp
       when Time then timestamp.to_java(ZonedDateTime)
       else

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

@@ -10,7 +10,7 @@ module OpenHAB
       DateTimeType = org.openhab.core.library.types.DateTimeType
 
       # global alias - required for jrubyscripting addon <= OH3.2.0
-      ::DateTimeType = DateTimeType if ::DateTimeType.is_a?(Java::JavaLang::Class)
+      ::DateTimeType = DateTimeType if ::DateTimeType.is_a?(java.lang.Class)
 
       # @deprecated
       # Backwards-compatible alias

data/lib/openhab/dsl/types/hsb_type.rb

@@ -9,7 +9,7 @@ module OpenHAB
       HSBType = org.openhab.core.library.types.HSBType
 
       # global alias - required for jrubyscripting addon <= OH3.2.0
-      ::HSBType = HSBType if ::HSBType.is_a?(Java::JavaLang::Class)
+      ::HSBType = HSBType if ::HSBType.is_a?(java.lang.Class)
 
       # Adds methods to core OpenHAB HSBType to make it more natural in Ruby
       class HSBType < PercentType

data/lib/openhab/dsl/types/percent_type.rb

@@ -8,7 +8,7 @@ module OpenHAB
       PercentType = org.openhab.core.library.types.PercentType
 
       # global alias - required for jrubyscripting addon <= OH3.2.0
-      ::PercentType = PercentType if ::PercentType.is_a?(Java::JavaLang::Class)
+      ::PercentType = PercentType if ::PercentType.is_a?(java.lang.Class)
 
       # Adds methods to core OpenHAB PercentType to make it more natural in Ruby
       class PercentType < DecimalType

data/lib/openhab/dsl/types/point_type.rb

@@ -7,7 +7,7 @@ module OpenHAB
 
       # global scope - required for jrubyscripting addon <= OH3.2.0
       # @!visibility private
-      ::PointType = PointType if ::PointType.is_a?(Java::JavaLang::Class)
+      ::PointType = PointType if ::PointType.is_a?(java.lang.Class)
 
       # Adds methods to core OpenHAB PointType to make it more natural in Ruby
       class PointType

data/lib/openhab/dsl/types/quantity_type.rb

@@ -8,7 +8,7 @@ module OpenHAB
       QuantityType = org.openhab.core.library.types.QuantityType
 
       # global alias - required for jrubyscripting addon <= OH3.2.0
-      ::QuantityType = QuantityType if ::QuantityType.is_a?(Java::JavaLang::Class)
+      ::QuantityType = QuantityType if ::QuantityType.is_a?(java.lang.Class)
 
       # @deprecated
       # Backwards-compatible alias

data/lib/openhab/version.rb

@@ -5,5 +5,5 @@
 #
 module OpenHAB
   # @return [String] Version of OpenHAB helper libraries
-  VERSION = '4.43.1'
+  VERSION = '4.44.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openhab-scripting
 version: !ruby/object:Gem::Version
-  version: 4.43.1
+  version: 4.44.0
 platform: ruby
 authors:
 - Brian O'Connell
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-07-18 00:00:00.000000000 Z
+date: 2022-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -116,6 +116,7 @@ files:
 - lib/openhab/dsl/rules/automation_rule.rb
 - lib/openhab/dsl/rules/guard.rb
 - lib/openhab/dsl/rules/item_event.rb
+- lib/openhab/dsl/rules/name_inference.rb
 - lib/openhab/dsl/rules/property.rb
 - lib/openhab/dsl/rules/rule.rb
 - lib/openhab/dsl/rules/rule_config.rb