openhab-jrubyscripting 5.0.0.rc2 → 5.0.0.rc3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0e925ebd72648fa8efb76592f6053d12f2fe9151173fa91d3f47a2d298f268fc
-  data.tar.gz: 6d84217a8505a72e2da686188a741d6644eee645255595d5d2cf455a2840e015
+  metadata.gz: ce249607265a008aa969e2edbd56302edd70a67a01dfebaec9ad67b7e5f1ad27
+  data.tar.gz: ac0c8d25509a8be8374a3f15fecd2e575da8cb08b82268aef41414f64f7a3b38
 SHA512:
-  metadata.gz: 5330bd233b45839cf1780815e86d170ff8a33b4093debfe85cae7e09e631d7a14c7bb2c7e84500da6a41fd0b89f81a160e4279659312323e6fb207bd0da6e632
-  data.tar.gz: 28f42c9a625aa33ef258f4d789e9fe116a1bf36e63bc58e2574d1a884ed8bde74bac03484566abd04909462ec4c9bdef543973416a2420fa02fea274122e3889
+  metadata.gz: 7c082f0949b6bc55ebf48b1489eade3f6bbcf25181d6741e29697dbb5ef5221abf583c78fb8ad46596b5ea10957e9d4b5d2d5dfe35097eea004f005d06683d48
+  data.tar.gz: ee7e740d0dd1233462521313c31145971bed68e2830c765bad27b8762d064bdf154993a2d733fc7743240bd55aec9e0eecd8cb4f2d569dbd0c599e765140cd06

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

@@ -65,16 +65,23 @@ module OpenHAB
         #
         # Send a command to this item
         #
+        # When this method is chained after the {OpenHAB::DSL::Items::Ensure::Ensurable#ensure ensure}
+        # method, or issued inside an {OpenHAB::DSL.ensure_states ensure_states} block,
+        # the command will only be sent if the item is not already in the same state.
+        #
         # @param [Command] command command to send to the item
-        # @return [self]
+        # @return [self, nil] nil when `ensure` is in effect and the item was already in the same state,
+        #   otherwise the item.
         #
-        # @see DSL::Items::TimedCommand#command
+        # @see DSL::Items::TimedCommand#command Timed Command
+        # @see OpenHAB::DSL.ensure_states ensure_states
+        # @see DSL::Items::Ensure::Ensurable#ensure ensure
         #
         def command(command)
           command = format_command(command)
           logger.trace "Sending Command #{command} to #{name}"
           $events.send_command(self, command)
-          self
+          Proxy.new(self)
         end
 
         # not an alias to allow easier stubbing and overriding
@@ -88,13 +95,14 @@ module OpenHAB
         # Send an update to this item
         #
         # @param [State] state
-        # @return [self]
+        # @return [self, nil] nil when `ensure` is in effect and the item was already in the same state,
+        #   otherwise the item.
         #
         def update(state)
           state = format_update(state)
           logger.trace "Sending Update #{state} to #{name}"
           $events.post_update(self, state)
-          self
+          Proxy.new(self)
         end
 
         #

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

@@ -26,7 +26,7 @@ module OpenHAB
 
           extend Forwardable
           def_delegators :@metadata, :configuration, :hash, :to_s, :uid, :value
-          protected :configuration
+          private :configuration
 
           # @!method to_hash
           #   Implicit conversion to {::Hash}.
@@ -37,6 +37,9 @@ module OpenHAB
           # still others (mutators) must be manually implemented below.
           def_delegators :configuration,
                          :any?,
+                         :compact,
+                         :compare_by_identity?,
+                         :deconstruct_keys,
                          :default,
                          :default_proc,
                          :each,
@@ -47,6 +50,8 @@ module OpenHAB
                          :filter,
                          :flatten,
                          :has_value?,
+                         :invert,
+                         :key,
                          :keys,
                          :length,
                          :rassoc,
@@ -57,8 +62,10 @@ module OpenHAB
                          :to_a,
                          :to_h,
                          :to_hash,
+                         :transform_keys,
+                         :transform_values,
+                         :values,
                          :value?
-          def_delegators :to_h, :invert, :merge, :transform_keys, :transform_values
 
           def_delegator :uid, :namespace
 
@@ -88,7 +95,7 @@ module OpenHAB
           end
 
           # @!visibility private
-          def initialize(metadata)
+          def initialize(metadata = nil)
             @metadata = metadata
           end
 
@@ -156,7 +163,7 @@ module OpenHAB
               return false unless value == other.value
             end
 
-            to_h < other
+            configuration < other
           end
 
           # @!visibility private
@@ -166,7 +173,7 @@ module OpenHAB
               return false unless value == other.value
             end
 
-            to_h <= other
+            configuration <= other
           end
 
           # @!visibility private
@@ -176,7 +183,7 @@ module OpenHAB
 
               return configuration == other.configuration
             elsif value.empty? && other.respond_to?(:to_hash)
-              return configuration.to_h == other.to_hash
+              return configuration == other.to_hash
             end
             false
           end
@@ -188,7 +195,7 @@ module OpenHAB
               return false unless value == other.value
             end
 
-            to_h > other
+            configuration > other
           end
 
           # @!visibility private
@@ -198,7 +205,7 @@ module OpenHAB
               return false unless value == other.value
             end
 
-            to_h >= other
+            configuration >= other
           end
 
           # @!visibility private
@@ -226,13 +233,9 @@ module OpenHAB
             replace({})
           end
 
-          # @!visibility private
-          alias_method :compact, :to_h
-
           # @!visibility private
           def compact!
-            # no action; impossible to have nil keys
-            self
+            replace(compact)
           end
 
           # @!visibility private
@@ -240,16 +243,6 @@ module OpenHAB
             raise NotImplementedError
           end
 
-          # @!visibility private
-          def compare_by_identity?
-            false
-          end
-
-          # @!visibility private
-          def deconstruct_keys
-            self
-          end
-
           # @!visibility private
           def default=(*)
             raise NotImplementedError
@@ -304,11 +297,6 @@ module OpenHAB
             self
           end
 
-          # @!visibility private
-          def key(value)
-            rassoc(value)&.first
-          end
-
           # @!visibility private
           def key?(key)
             configuration.key?(key.to_s)
@@ -360,7 +348,7 @@ module OpenHAB
 
           # @!visibility private
           def slice(*keys)
-            to_h.slice(*keys.map(&:to_s))
+            configuration.slice(*keys.map(&:to_s))
           end
 
           # @!visibility private
@@ -380,11 +368,6 @@ module OpenHAB
             replace(transform_values(&block))
           end
 
-          # @!visibility private
-          def values
-            configuration.values.to_a
-          end
-
           # @!visibility private
           def values_at(*keys)
             configuration.values_at(*keys.map(&:to_s))

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "delegate"
+
 require_relative "generic_item"
 
 module OpenHAB

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

@@ -72,15 +72,17 @@ module Enumerable
   # @!group Items State and Command Methods
 
   # Send a command to every item in the collection
-  # @return [self]
+  # @return [self, nil] nil when `ensure` is in effect and all the items were already in the same state,
+  #   otherwise self
   def command(command)
-    each { |i| i.command(command) }
+    self if count { |i| i.command(command) }.positive?
   end
 
   # Update the state of every item in the collection
-  # @return [self]
+  # @return [self, nil] nil when `ensure` is in effect and all the items were already in the same state,
+  #   otherwise self
   def update(state)
-    each { |i| i.update(state) }
+    self if count { |i| i.update(state) }.positive?
   end
 
   # @!method refresh

data/lib/openhab/core/profile_factory.rb

@@ -87,6 +87,8 @@ module OpenHAB
           DSL::ThreadLocal.thread_local(**@thread_locals) do
             @block.call(event, **kwargs)
           rescue Exception => e
+            raise if defined?(::RSpec)
+
             @block.binding.eval("self").logger.log_exception(e)
           end
         end

data/lib/openhab/core/provider.rb

@@ -13,6 +13,7 @@ module OpenHAB
       TYPE_TO_PROVIDER_TYPE = {
         org.openhab.core.items.Item.java_class => :items,
         org.openhab.core.items.Metadata.java_class => :metadata,
+        org.openhab.core.automation.Rule.java_class => :rules,
         org.openhab.core.thing.Thing.java_class => :things,
         org.openhab.core.thing.link.ItemChannelLink.java_class => :links
       }.freeze
@@ -37,6 +38,7 @@ module OpenHAB
     # @abstract
     class Provider < org.openhab.core.common.registry.AbstractProvider
       include org.openhab.core.common.registry.ManagedProvider
+      include Enumerable
       include Singleton
       public_class_method :new
 
@@ -140,6 +142,11 @@ module OpenHAB
         end
       end
 
+      # @!visibility private
+      def each(&block)
+        @elements.each_value(&block)
+      end
+
       # @return [String]
       def inspect
         "#<#{self.class.name}:#{object_id}>"
@@ -192,7 +199,7 @@ module OpenHAB
       def update(element)
         old_element = @elements[element.uid]
         if old_element
-          @elements[element.uid]
+          @elements[element.uid] = element
           notify_listeners_about_updated_element(old_element, element)
         end
         old_element

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module Core
+    module Rules
+      #
+      # Provides rules created in Ruby to openHAB
+      #
+      class Provider < Core::Provider
+        include org.openhab.core.automation.RuleProvider
+
+        class << self
+          #
+          # The Rule registry
+          #
+          # @return [org.openhab.core.automation.RuleRegistry]
+          #
+          def registry
+            $rules
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+module OpenHAB
+  module Core
+    module Rules
+      #
+      # Provides access to all OpenHAB {Rule rules}, and acts like an array.
+      #
+      class Registry
+        include LazyArray
+        include Singleton
+
+        #
+        # Gets a specific Rule
+        #
+        # @param [String] uid Rule UID
+        # @return [Rule, nil]
+        #
+        def [](uid)
+          $rules.get(uid)
+        end
+        alias_method :include?, :[]
+        alias_method :key?, :[]
+        # @deprecated
+        alias_method :has_key?, :[]
+
+        #
+        # Explicit conversion to array
+        #
+        # @return [Array<Rule>]
+        #
+        def to_a
+          $rules.all.to_a
+        end
+
+        #
+        # Enter the Rule Builder DSL.
+        # @param (see Core::Provider.current)
+        # @yield Block executed in the context of a {DSL::Rules::Builder}.
+        # @return [Object] The result of the block.
+        #
+        def build(preferred_provider = nil, &block)
+          DSL::Rules::Builder.new(preferred_provider).instance_eval(&block)
+        end
+
+        #
+        # Remove a Rule.
+        #
+        # The rule must be a managed thing (typically created by Ruby or in the UI).
+        #
+        # @param [String, Rule] rule_uid
+        # @return [Rule, nil] The removed rule, if found.
+        #
+        # @example
+        #   my_rule = rule do
+        #     every :day
+        #     run { nil }
+        #   end
+        #
+        #   rules.remove(my_rule)
+        #
+        def remove(rule_uid)
+          rule_uid = rule_uid.uid if rule_uid.is_a?(Rule)
+          provider = Provider.registry.provider_for(rule_uid)
+          unless provider.is_a?(org.openhab.core.common.registry.ManagedProvider)
+            raise "Cannot remove rule #{rule_uid} from non-managed provider #{provider.inspect}"
+          end
+
+          provider.remove(rule_uid)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module Core
+    module Rules
+      # @interface
+      java_import org.openhab.core.automation.Rule
+
+      #
+      # A {Rule} is a chunk of code that can execute when certain conditions are
+      # met, enabling the core dynamic functionality of openHAB.
+      #
+      module Rule
+        #
+        # @!method visible?
+        #   Check if visibility == `VISIBLE`
+        #   @return [true,false]
+        #
+
+        #
+        # @!method hidden?
+        #   Check if visibility == `HIDDEN`
+        #   @return [true,false]
+        #
+
+        #
+        # @!method expert?
+        #   Check if visibility == `EXPERT`
+        #   @return [true,false]
+        #
+
+        #
+        # @!method initializing?
+        #   Check if rule status == `INITIALIZING`
+        #   @return [true,false]
+        #
+        #
+        # @!method idle?
+        #   Check if rule status == `IDLE`
+        #   @return [true,false]
+        #
+        #
+        # @!method running?
+        #   Check if rule status == `RUNNING`
+        #   @return [true,false]
+        #
+
+        Visibility.constants.each do |visibility|
+          class_eval <<~RUBY, __FILE__, __LINE__ + 1
+            def #{visibility.to_s.downcase}?           # def visibile?
+              visibility == Visibility::#{visibility}  #   visibility == Visibility::VISIBLE
+            end                                        # end
+          RUBY
+        end
+
+        RuleStatus.constants.each do |status|
+          next if status == :UNINITIALIZED
+
+          class_eval <<~RUBY, __FILE__, __LINE__ + 1
+            def #{status.to_s.downcase}?       # def initializing?
+              status == RuleStatus::#{status}  #   status == RuleStatus::INITIALIZING
+            end                                # end
+          RUBY
+        end
+
+        #
+        # Check if rule status == `UNINITIALIZED`
+        #
+        # @return [true,false]
+        #
+        def uninitialized?
+          s = status
+          s.nil? || s == RuleStatus::UNINITIALIZED
+        end
+
+        #
+        # Enable the Rule
+        #
+        # @param [true, false] enabled
+        # @return [void]
+        #
+        def enable(enabled: true)
+          Rules.manager.set_enabled(uid, enabled)
+        end
+
+        #
+        # Disable the Rule
+        #
+        # @return [void]
+        #
+        def disable
+          enable(enabled: false)
+        end
+
+        #
+        # Check if the rule's status detail == `DISABLED`
+        #
+        # @return [true, false]
+        #
+        def disabled?
+          info = status_info
+          info.nil? || info.status_detail == RuleStatusDetail::DISABLED
+        end
+
+        #
+        # @!attribute [r] status
+        # @return [RuleStatus nil]
+        #
+        def status
+          Rules.manager.get_status(uid)
+        end
+
+        #
+        # @!attribute [r] status_info
+        # @return [RuleStatusInfo, nil]
+        #
+        def status_info
+          Rules.manager.get_status_info(uid)
+        end
+
+        # @return [String]
+        def inspect
+          r = "#<OpenHAB::Core::Rules::Rule #{uid}"
+          r += " #{name.inspect}" if name
+          r += " #{visibility}" unless visible?
+          r += " #{status || "<detached>"}"
+          r += " (#{status_info.status_detail})" if status_info && status_info.status_detail != RuleStatusDetail::NONE
+          r += " tags=#{tags.to_a.inspect}" unless tags.empty?
+          r += " configuration=#{configuration.properties.to_h}" if configuration && !configuration.properties.empty?
+          "#{r}>"
+        end
+
+        # @return [String]
+        def to_s
+          uid
+        end
+
+        #
+        # 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 })
+        end
+      end
+    end
+  end
+end

data/lib/openhab/core/rules.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module Core
+    #
+    # Contains the core {Rule} as well as related infrastructure.
+    #
+    module Rules
+      java_import org.openhab.core.automation.RuleStatus,
+                  org.openhab.core.automation.RuleStatusInfo,
+                  org.openhab.core.automation.RuleStatusDetail,
+                  org.openhab.core.automation.Visibility
+
+      class << self
+        #
+        # @!attribute [r] rule_manager
+        # @return [org.openhab.core.automation.RuleManager] The OpenHAB rule manager/engine
+        #
+        def manager
+          @manager ||= OSGi.service("org.openhab.core.automation.RuleManager")
+        end
+      end
+    end
+  end
+end

data/lib/openhab/core/timer.rb

@@ -35,7 +35,6 @@ module OpenHAB
       # @return [Object, nil]
       attr_accessor :id
 
-      # @!visibility private
       # @!visibility private
       attr_reader :block
 
@@ -84,6 +83,7 @@ module OpenHAB
       # @return [self]
       #
       def reschedule(time = nil)
+        Thread.current[:openhab_rescheduled_timer] = true if Thread.current[:openhab_rescheduled_timer] == self
         DSL.timers.add(self)
         @timer.reschedule(new_execution_time(time || @time))
         self
@@ -119,12 +119,10 @@ module OpenHAB
       # @return [void]
       #
       def execute
-        last_execution_time = execution_time
-        DSL::ThreadLocal.thread_local(**@thread_locals) do
-          @block.call(self)
-        end
-        # don't remove ourselves if we were rescheduled in the block
-        DSL.timers.delete(self) if execution_time == last_execution_time
+        Thread.current[:openhab_rescheduled_timer] = self
+        DSL::ThreadLocal.thread_local(**@thread_locals) { @block.call(self) }
+        DSL.timers.delete(self) unless Thread.current[:openhab_rescheduled_timer] == true
+        Thread.current[:openhab_rescheduled_timer] = nil
       end
 
       #

data/lib/openhab/core/types.rb

@@ -13,7 +13,7 @@ module OpenHAB
     # Types are the specific data types that commands and states are. They can be
     # sent to items, be the current state of an item, or be the `command`, `state`,
     # and `was` field of various
-    # {group::OpenHAB::DSL::Rules::Builder::Triggers triggers}.
+    # {group::OpenHAB::DSL::Rules::BuilderDSL::Triggers triggers}.
     # Some types have additional useful methods.
     #
     module Types

data/lib/openhab/core.rb

@@ -53,22 +53,6 @@ module OpenHAB
       def automation_manager
         $scriptExtension.get("automationManager")
       end
-
-      #
-      # @!attribute [r] rule_registry
-      # @return [org.openhab.core.automation.RuleRegistry] The OpenHAB rule registry
-      #
-      def rule_registry
-        $scriptExtension.get("ruleRegistry")
-      end
-
-      #
-      # @!attribute [r] rule_manager
-      # @return [org.openhab.core.automation.RuleManager] The OpenHAB rule manager/engine
-      #
-      def rule_manager
-        @rule_manager ||= OSGi.service("org.openhab.core.automation.RuleManager")
-      end
     end
   end
 end