openhab-scripting 4.32.6 → 4.32.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 34c74d99bb0771d8c4bfda01a96e59565dd3cd204918c0726b4286350b987b8b
-  data.tar.gz: 17414fbbbf1ad48e9645f0bfdda0cd09703270695885d4938b5b74a22b9b1e84
+  metadata.gz: 1741788eaf0826f7b5e2c69935c96b21399771b3332a89debc77992c4ef687d0
+  data.tar.gz: b1200a71458efe21d389631bc29d2ef7d073ae5128706009a12b9a35af559bd3
 SHA512:
-  metadata.gz: 2d79c2e5349ec783bef23e2b47f279052c1602a271d05d0c28e1f46f651aa5303138a0ee092a521db3d452764c05787e0416e16ac1a36c1cb1afcb823d205009
-  data.tar.gz: 20f6d14f431456ab6cfafca83a36fdcc7ef1f7c0f2c2b960f819bfe896916e6b676968dd616fd656288d734ac03e733eea31b0345d122d727dbe43b6978117a9
+  metadata.gz: 9317316f15b212005f6f9cb4013c6fb80739b8c427a8685b0610d5c6127a1ed676584f62258efe38a757966f4c9e51f61064a70a486ec2bd4d0e98c52dbe9255
+  data.tar.gz: d28a7872616e92eefa43e198f8211ee6ccb4408f418bb942ea82b6a8c9af572f9d6adc2e8fe929d8a2ba5bff19138f238be0e7951f75bf9567800e5681c68381

data/lib/openhab/core/entity_lookup.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require 'pp'
-require 'java'
-require 'set'
-
 require 'openhab/log/logger'
 require_relative 'item_proxy'
 

data/lib/openhab/core/openhab_setup.rb

@@ -17,9 +17,8 @@ module OpenHAB
     #
     # Wait until OpenHAB engine ready to process
     #
-    #
     def self.wait_till_openhab_ready
-      logger.trace('Checking readyness of OpenHAB')
+      logger.trace('Checking readiness of OpenHAB')
       until OpenHAB::Core.automation_manager
         logger.trace("Automation manager not loaded, checking again in #{CHECK_DELAY} seconds.")
         sleep CHECK_DELAY

data/lib/openhab/core/thread_local.rb

@@ -15,9 +15,9 @@ module OpenHAB
       # Execute the supplied block with the supplied values set for the currently running thread
       # The previous values for each key are restored after the block is executed
       #
-      # @param [Hash] Keys and values to set for running thread, if hash is nil no values are set
+      # @param [Hash] values Keys and values to set for running thread, if hash is nil no values are set
       #
-      def thread_local(**values)
+      def self.thread_local(**values)
         old_values = values.map { |key, _value| [key, Thread.current[key]] }.to_h
         values.each { |key, value| Thread.current[key] = value }
         logger.trace "Executing block with thread local context: #{values} - old context: #{old_values}"
@@ -25,6 +25,16 @@ module OpenHAB
       ensure
         old_values.each { |key, value| Thread.current[key] = value }
       end
+
+      #
+      # Execute the supplied block with the supplied values set for the currently running thread
+      # The previous values for each key are restored after the block is executed
+      #
+      # @param [Hash] values Keys and values to set for running thread, if hash is nil no values are set
+      #
+      def thread_local(**values, &block)
+        ThreadLocal.thread_local(values, &block)
+      end
     end
   end
 end

data/lib/openhab/dsl/actions.rb

@@ -18,6 +18,8 @@ module OpenHAB
       # Import common actions
       %w[Exec HTTP Ping].each { |action| java_import "org.openhab.core.model.script.actions.#{action}" }
 
+      module_function
+
       #
       # Return an OpenHAB Action object for the given scope and thing
       #

data/lib/openhab/dsl/between.rb

@@ -7,6 +7,8 @@ module OpenHAB
   module DSL
     # Supports between range syntax
     module Between
+      module_function
+
       # Creates a range that can be compared against time of day/month days or strings
       # to see if they are within the range
       # @since 2.4.0

data/lib/openhab/dsl/dsl.rb

@@ -39,8 +39,8 @@ module OpenHAB
       base.send :include, OpenHAB::DSL::Groups
       base.send :include, OpenHAB::DSL::Items
       base.send :include, OpenHAB::DSL::Persistence
-      base.send :include, OpenHAB::DSL::Rules
-      base.send :include, OpenHAB::DSL::Rules::Terse
+      base.send :include, OpenHAB::DSL::Rules::Rule
+      base.send :include, OpenHAB::DSL::Rules::TerseRule
       base.send :include, OpenHAB::DSL::States
       base.send :include, OpenHAB::DSL::Things
       base.send :include, OpenHAB::DSL::Timers

data/lib/openhab/dsl/group.rb

@@ -2,8 +2,8 @@
 
 require 'singleton'
 
-require 'openhab/dsl/lazy_array'
 require 'openhab/core/entity_lookup'
+require 'openhab/dsl/lazy_array'
 
 module OpenHAB
   module DSL
@@ -11,6 +11,19 @@ module OpenHAB
     # Provides access to OpenHAB Groups
     #
     module Groups
+      module_function
+
+      #
+      # Retrieve all OpenHAB groups
+      #
+      # @return [Set] of OpenHAB Groups
+      #
+      def groups
+        OpenHAB::DSL::Support::Groups.instance
+      end
+    end
+
+    module Support
       #
       # Provide access to groups as a set
       #
@@ -26,7 +39,7 @@ module OpenHAB
         #
         def [](name)
           group = OpenHAB::Core::EntityLookup.lookup_item(name)
-          group.is_a?(Items::GroupItem) ? group : nil
+          group.is_a?(OpenHAB::DSL::Items::GroupItem) ? group : nil
         end
         alias include? []
         alias key? include?
@@ -36,15 +49,6 @@ module OpenHAB
           $ir.items.grep(org.openhab.core.items.GroupItem) # rubocop:disable Style/GlobalVars
         end
       end
-
-      #
-      # Retreive all OpenHAB groups
-      #
-      # @return [Set] of OpenHAB Groups
-      #
-      def groups
-        Groups.instance
-      end
     end
   end
 end

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

@@ -4,94 +4,94 @@ require_relative 'generic_item'
 
 module OpenHAB
   module DSL
-    module Items
-      # Functionality to implement +ensure+/+ensure_states+
-      module Ensure
-        # Contains the global +ensure_states+ method
-        module EnsureStates
-          # Global method that takes a block and for the duration of the block
-          # all commands sent will check if the item is in the command's state
-          # before sending the command.
-          #
-          # @example Turn on several switches only if they're not already on
-          #   ensure_states do
-          #     Switch1.on
-          #     Switch2.on
-          #   end
-          def ensure_states
-            old = Thread.current[:ensure_states]
-            Thread.current[:ensure_states] = true
-            yield
-          ensure
-            Thread.current[:ensure_states] = old
-          end
-          module_function :ensure_states
+    # Functionality to implement +ensure+/+ensure_states+
+    module Ensure
+      # Contains the global +ensure_states+ method
+      module EnsureStates
+        # Global method that takes a block and for the duration of the block
+        # all commands sent will check if the item is in the command's state
+        # before sending the command.
+        #
+        # @example Turn on several switches only if they're not already on
+        #   ensure_states do
+        #     Switch1.on
+        #     Switch2.on
+        #   end
+        def ensure_states
+          old = Thread.current[:ensure_states]
+          Thread.current[:ensure_states] = true
+          yield
+        ensure
+          Thread.current[:ensure_states] = old
         end
+        module_function :ensure_states
+      end
 
-        # Contains the +ensure+ method mixed into {GenericItem} and {GroupItem::GroupMembers}
-        module Ensurable
-          # Fluent method call that you can chain commands on to, that will
-          # then automatically ensure that the item is not in the command's
-          # state before sending the command.
-          #
-          # @example Turn switch on only if it's not on
-          #   MySwitch.ensure.on
-          # @example Turn on all switches in a group that aren't already on
-          #   MySwitchGroup.members.ensure.on
-          def ensure
-            GenericItemDelegate.new(self)
-          end
+      # Contains the +ensure+ method mixed into {GenericItem} and {GroupItem::GroupMembers}
+      module Ensurable
+        # Fluent method call that you can chain commands on to, that will
+        # then automatically ensure that the item is not in the command's
+        # state before sending the command.
+        #
+        # @example Turn switch on only if it's not on
+        #   MySwitch.ensure.on
+        # @example Turn on all switches in a group that aren't already on
+        #   MySwitchGroup.members.ensure.on
+        def ensure
+          GenericItemDelegate.new(self)
         end
+      end
 
-        # Extensions for {Items::GenericItem} to implement {Ensure}'s
-        # functionality
-        module GenericItem
-          include Ensurable
-
-          # If +ensure_states+ is active (by block or chained method), then
-          # check if this item is in the command's state before actually
-          # sending the command
-          def command(command)
-            return super unless Thread.current[:ensure_states]
+      # Extensions for {Items::GenericItem} to implement {Ensure}'s
+      # functionality
+      module GenericItem
+        include Ensurable
 
-            logger.trace do
-              "#{name} ensure #{command}, format_type_pre: #{format_type_pre(command)}, current state: #{state}"
-            end
-            return if state == format_type_pre(command)
+        # If +ensure_states+ is active (by block or chained method), then
+        # check if this item is in the command's state before actually
+        # sending the command
+        def command(command)
+          return super unless Thread.current[:ensure_states]
 
-            super
+          logger.trace do
+            "#{name} ensure #{command}, format_type_pre: #{format_type_pre(command)}, current state: #{state}"
           end
-          alias << command
+          return if state == format_type_pre(command)
+
+          super
         end
+        alias << command
+      end
 
-        # "anonymous" class that wraps any method call in +ensure_states+
-        # before forwarding to the wrapped object
-        # @!visibility private
-        class GenericItemDelegate
-          def initialize(item)
-            @item = item
-          end
+      # "anonymous" class that wraps any method call in +ensure_states+
+      # before forwarding to the wrapped object
+      # @!visibility private
+      class GenericItemDelegate
+        def initialize(item)
+          @item = item
+        end
 
-          # activate +ensure_states+ before forwarding to the wrapped object
-          def method_missing(method, *args, &block)
-            return super unless @item.respond_to?(method)
+        # activate +ensure_states+ before forwarding to the wrapped object
+        def method_missing(method, *args, &block)
+          return super unless @item.respond_to?(method)
 
-            ensure_states do
-              @item.__send__(method, *args, &block)
-            end
+          ensure_states do
+            @item.__send__(method, *args, &block)
           end
+        end
 
-          # .
-          def respond_to_missing?(method, include_private = false)
-            @item.respond_to?(method, include_private) || super
-          end
+        # .
+        def respond_to_missing?(method, include_private = false)
+          @item.respond_to?(method, include_private) || super
         end
       end
+    end
 
-      GenericItem.prepend(Ensure::GenericItem)
-      GroupItem::GroupMembers.include(Ensure::Ensurable)
+    module Items
+      GenericItem.prepend(OpenHAB::DSL::Ensure::GenericItem)
+      GroupItem::GroupMembers.include(OpenHAB::DSL::Ensure::Ensurable)
     end
   end
 end
 
-Object.include OpenHAB::DSL::Items::Ensure::EnsureStates
+Object.include OpenHAB::DSL::Ensure::EnsureStates

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

@@ -153,7 +153,7 @@ module OpenHAB
         def things
           registry = OpenHAB::Core::OSGI.service('org.openhab.core.thing.link.ItemChannelLinkRegistry')
           channels = registry.get_bound_channels(name).to_a
-          channels.map(&:thing_uid).uniq.map { |tuid| Object.things[tuid] }
+          channels.map(&:thing_uid).uniq.map { |tuid| OpenHAB::DSL::Things.things[tuid] }
         end
         alias all_linked_things things
 

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

@@ -8,6 +8,17 @@ require 'openhab/dsl/lazy_array'
 module OpenHAB
   module DSL
     module Items
+      module_function
+
+      # Fetches all non-group items from the item registry
+      # @return [ItemRegistry]
+      def items
+        OpenHAB::DSL::Support::ItemRegistry.instance
+      end
+    end
+
+    # Provide supporting objects for DSL functions
+    module Support
       #
       # Provides access to all OpenHAB items, and acts like an array.
       #
@@ -38,12 +49,6 @@ module OpenHAB
           $ir.items.to_a # rubocop:disable Style/GlobalVars
         end
       end
-
-      # Fetches all non-group items from the item registry
-      # @return [ItemRegistry]
-      def items
-        ItemRegistry.instance
-      end
     end
   end
 end

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

@@ -43,7 +43,7 @@ module OpenHAB
         # define predicates for checking if an item is in one of the Enum states
         def def_predicate_methods(klass)
           values_for_enums(klass.ACCEPTED_DATA_TYPES).each do |state|
-            _command_predicate, state_predicate = Types::PREDICATE_ALIASES[state.to_s]
+            _command_predicate, state_predicate = OpenHAB::DSL::PREDICATE_ALIASES[state.to_s]
             next if klass.instance_methods.include?(state_predicate)
 
             logger.trace("Defining #{klass}##{state_predicate} for #{state}")
@@ -59,7 +59,7 @@ module OpenHAB
         # as well as predicates for if an ItemCommandEvent is one of those commands
         def def_command_methods(klass) # rubocop:disable Metrics method has single purpose
           values_for_enums(klass.ACCEPTED_COMMAND_TYPES).each do |value|
-            command = Types::COMMAND_ALIASES[value.to_s]
+            command = OpenHAB::DSL::COMMAND_ALIASES[value.to_s]
             next if klass.instance_methods.include?(command)
 
             logger.trace("Defining #{klass}##{command} for #{value}")

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

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'delegate'
-require 'pp'
 require 'forwardable'
 require 'openhab/core/osgi'
 require 'openhab/log/logger'
@@ -89,7 +88,7 @@ module OpenHAB
           #
           # Recursively convert the supplied Hash object into a Ruby Hash and recreate the keys and values
           #
-          # @param [Hash] Hash to convert
+          # @param [Hash] hash to convert
           #
           # @return [Hash] The converted hash
           #

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

@@ -43,7 +43,7 @@ module OpenHAB
           #
           #
           # rubocop: disable Metrics/MethodLength
-          # The mutex makes this over 10 lines, but there is usable way to break thsi method up
+          # The mutex makes this over 10 lines, but there is usable way to break this method up
           def command(command, for: nil, on_expire: nil, &block)
             duration = binding.local_variable_get(:for)
             return super(command) unless duration
@@ -86,8 +86,9 @@ module OpenHAB
             timed_command_details.timer = timed_command_timer(timed_command_details, semaphore, &block)
             timed_command_details.cancel_rule = TimedCommandCancelRule.new(timed_command_details, semaphore,
                                                                            &block)
-            timed_command_details.rule_uid = OpenHAB::DSL::Rules.automation_manager
-                                                                .addRule(timed_command_details.cancel_rule).getUID
+            timed_command_details.rule_uid = OpenHAB::DSL::Rules::Rule.automation_manager
+                                                                      .addRule(timed_command_details.cancel_rule)
+                                                                      .getUID
             logger.trace "Created Timed Command #{timed_command_details}"
             TimedCommand.timed_commands[self] = timed_command_details
           end
@@ -120,10 +121,10 @@ module OpenHAB
           # rubocop: enable Metrics/MethodLength
 
           # Cancels timed command rule
-          # @param [TimedCommandDetailed] timed_command details about the timed command
+          # @param [TimedCommandDetailed] timed_command_details details about the timed command
           def cancel_timed_command_rule(timed_command_details)
             logger.trace "Removing rule: #{timed_command_details.rule_uid}"
-            OpenHAB::DSL::Rules.registry.remove(timed_command_details.rule_uid)
+            OpenHAB::DSL::Rules::Rule.registry.remove(timed_command_details.rule_uid)
           end
 
           #
@@ -162,7 +163,7 @@ module OpenHAB
             #
             # Execute the rule
             #
-            # @param [Map] mod map provided by OpenHAB rules engine
+            # @param [Map] _mod map provided by OpenHAB rules engine
             # @param [Map] inputs map provided by OpenHAB rules engine containing event and other information
             #
             #

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

@@ -8,8 +8,6 @@ module OpenHAB
         # Extend integer to create duration object
         #
         module IntegerExtensions
-          include OpenHAB::Core
-
           #
           # Create Duration with the specified unit
           #

data/lib/openhab/dsl/openhab.rb

@@ -10,6 +10,8 @@ module OpenHAB
     module Core
       include OpenHAB::Log
 
+      module_function
+
       #
       # Return the OpenHAB conf directory as a ruby pathname
       #

data/lib/openhab/dsl/persistence.rb

@@ -6,6 +6,8 @@ module OpenHAB
     # Provides support for interacting with OpenHAB Persistence service
     #
     module Persistence
+      module_function
+
       #
       # Sets a thread local variable to set the default persistence service
       # for method calls inside the block

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

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'java'
-require 'set'
 require 'openhab/core/thread_local'
 require 'openhab/log/logger'
 require 'openhab/dsl/between'
@@ -57,8 +56,8 @@ module OpenHAB
         #
         def execute(mod = nil, inputs = nil)
           thread_local(RULE_NAME: name) do
-            logger.trace { "Execute called with mod (#{mod&.to_string}) and inputs (#{inputs&.pretty_inspect})" }
-            logger.trace { "Event details #{inputs['event'].pretty_inspect}" } if inputs&.key?('event')
+            logger.trace { "Execute called with mod (#{mod&.to_string}) and inputs (#{inputs.inspect})" }
+            logger.trace { "Event details #{inputs['event'].inspect}" } if inputs&.key?('event')
             trigger_conditions(inputs).process(mod: mod, inputs: inputs) do
               process_queue(create_queue(inputs), mod, inputs)
             end
@@ -131,8 +130,8 @@ module OpenHAB
         end
 
         # If an attachment exists for the trigger for this event add it to the event object
-        # @param [Object] Event
-        # @param [Hash] Inputs into event
+        # @param [Object] event Event
+        # @param [Hash] inputs Inputs into event
         # @return [Object] Event with attachment added
         #
         def add_attachment(event, inputs)