openhab-jrubyscripting 5.0.0.rc2 → 5.0.0.rc3

data/lib/openhab/core_ext/ruby/time.rb

@@ -2,103 +2,105 @@
 
 require "forwardable"
 
-module OpenHAB
-  module CoreExt
-    module Ruby
-      # Extensions to Time and DateTime
-      module TimeExtensions
-        extend Forwardable
-
-        # @!visibility private
-        def self.included(base)
-          base.send :alias_method, :plus_without_temporal, :+
-          base.send :alias_method, :+, :plus_with_temporal
-          base.send :alias_method, :minus_without_temporal, :-
-          base.send :alias_method, :-, :minus_with_temporal
-        end
+# Extensions to Time
+class Time
+  extend Forwardable
 
-        #
-        # @!method +(other)
-        #
-        # Extends {#+} to allow adding a {java.time.temporal.TemporalAmount TemporalAmount}
-        #
-        # @param [java.time.temporal.TemporalAmount] other
-        # @return [ZonedDateTime] If other is a {java.time.temporal.TemporalAmount TemporalAmount}
-        # @return [Time] If other is a Numeric
-        #
-        def plus_with_temporal(other)
-          return to_zoned_date_time + other if other.is_a?(java.time.temporal.TemporalAmount)
+  #
+  # @!method +(other)
+  #
+  # Extends {#+} to allow adding a {java.time.temporal.TemporalAmount TemporalAmount}
+  #
+  # @param [java.time.temporal.TemporalAmount] other
+  # @return [ZonedDateTime] If other is a {java.time.temporal.TemporalAmount TemporalAmount}
+  # @return [Time] If other is a Numeric
+  #
+  def plus_with_temporal(other)
+    return to_zoned_date_time + other if other.is_a?(java.time.temporal.TemporalAmount)
 
-          plus_without_temporal(other)
-        end
+    plus_without_temporal(other)
+  end
+  alias_method :plus_without_temporal, :+
+  alias_method :+, :plus_with_temporal
 
-        #
-        # @!method -(other)
-        #
-        # Extends {#-} to allow subtracting a {java.time.temporal.TemporalAmount TemporalAmount}
-        #
-        # @param [java.time.temporal.TemporalAmount] other
-        # @return [ZonedDateTime] If other is a {java.time.temporal.TemporalAmount TemporalAmount}
-        # @return [Time] If other is a Numeric
-        #
-        def minus_with_temporal(other)
-          return to_zoned_date_time - other if other.is_a?(java.time.temporal.TemporalAmount)
+  #
+  # @!method -(other)
+  #
+  # Extends {#-} to allow subtracting a {java.time.temporal.TemporalAmount TemporalAmount}
+  # or any other date/time class that responds to #to_zoned_date_time.
+  #
+  # Subtractions with another object of the same class (e.g. Time - Other Time, or DateTime - Other DateTime)
+  # remains unchanged from its original behavior.
+  #
+  # @example Time - Duration -> ZonedDateTime
+  #   zdt_one_hour_ago = Time.now - 1.hour
+  #
+  # @example Time - ZonedDateTime -> Duration
+  #   java_duration = Time.now - 1.hour.ago
+  #
+  # @example Time - Numeric -> Time
+  #   time_one_hour_ago = Time - 3600
+  #
+  # @example Time - Time -> Float
+  #   one_day_in_secs = Time.new(2002, 10, 31) - Time.new(2002, 10, 30)
+  #
+  # @param [java.time.temporal.TemporalAmount, #to_zoned_date_time] other
+  # @return [ZonedDateTime] If other is a {java.time.temporal.TemporalAmount TemporalAmount}
+  # @return [Duration] If other responds to #to_zoned_date_time
+  # @return [Time] If other is a Numeric
+  # @return [Float] If other is a Time
+  #
+  def minus_with_temporal(other)
+    return to_zoned_date_time - other if other.is_a?(java.time.temporal.TemporalAmount)
 
-          minus_without_temporal(other)
-        end
+    # Exclude subtracting against the same class
+    if other.respond_to?(:to_zoned_date_time) && !other.is_a?(self.class)
+      return to_zoned_date_time - other.to_zoned_date_time
+    end
 
-        # @return [LocalDate]
-        def to_local_date(_context = nil)
-          java.time.LocalDate.of(year, month, day)
-        end
+    minus_without_temporal(other)
+  end
+  alias_method :minus_without_temporal, :-
+  alias_method :-, :minus_with_temporal
 
-        # @!method to_local_time
-        #   @return [LocalTime]
-        def_delegator :to_zoned_date_time, :to_local_time
+  # @return [LocalDate]
+  def to_local_date(_context = nil)
+    java.time.LocalDate.of(year, month, day)
+  end
 
-        # @return [Month]
-        def to_month
-          java.time.Month.of(month)
-        end
+  # @!method to_local_time
+  #   @return [LocalTime]
+  def_delegator :to_zoned_date_time, :to_local_time
 
-        # @return [MonthDay]
-        def to_month_day
-          java.time.MonthDay.of(month, day)
-        end
+  # @return [Month]
+  def to_month
+    java.time.Month.of(month)
+  end
 
-        # @param [ZonedDateTime, nil] context
-        #   A {ZonedDateTime} used to fill in missing fields
-        #   during conversion. Not used in this class.
-        # @return [ZonedDateTime]
-        def to_zoned_date_time(context = nil) # rubocop:disable Lint/UnusedMethodArgument
-          to_java(ZonedDateTime)
-        end
+  # @return [MonthDay]
+  def to_month_day
+    java.time.MonthDay.of(month, day)
+  end
 
-        #
-        # Converts to a {ZonedDateTime} if `other`
-        # is also convertible to a ZonedDateTime.
-        #
-        # @param [#to_zoned_date_time] other
-        # @return [Array, nil]
-        #
-        def coerce(other)
-          [other.to_zoned_date_time(to_zoned_date_time), self] if other.respond_to?(:to_zoned_date_time)
-        end
-      end
-    end
+  # @param [ZonedDateTime, nil] context
+  #   A {ZonedDateTime} used to fill in missing fields
+  #   during conversion. Not used in this class.
+  # @return [ZonedDateTime]
+  def to_zoned_date_time(context = nil) # rubocop:disable Lint/UnusedMethodArgument
+    to_java(java.time.ZonedDateTime)
   end
-end
 
-#
-# Extensions to Ruby Time
-#
-class Time
-  include(OpenHAB::CoreExt::Ruby::TimeExtensions)
-end
+  #
+  # Converts to a {ZonedDateTime} if `other`
+  # is also convertible to a ZonedDateTime.
+  #
+  # @param [#to_zoned_date_time] other
+  # @return [Array, nil]
+  #
+  def coerce(other)
+    return unless other.respond_to?(:to_zoned_date_time)
 
-#
-# Extensions to Ruby DateTime
-#
-class DateTime
-  include(OpenHAB::CoreExt::Ruby::TimeExtensions)
+    zdt = to_zoned_date_time
+    [other.to_zoned_date_time(zdt), zdt]
+  end
 end

data/lib/openhab/dsl/events/watch_event.rb

@@ -4,7 +4,7 @@ module OpenHAB
   module DSL
     module Events
       #
-      # Event object passed by a {Rules::Builder#watch} trigger.
+      # Event object passed by a {Rules::BuilderDSL#watch} trigger.
       #
       # @!attribute [r] path
       #   @return [Pathname] The path that had an event

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

@@ -40,7 +40,7 @@ module OpenHAB
             class_eval <<~RUBY, __FILE__, __LINE__ + 1
               def #{method}_item(*args, **kwargs, &block)         # def dimmer_item(*args, **kwargs, &block)
                 item(#{method.inspect}, *args, **kwargs, &block)  #   item(:dimmer, *args, **kwargs, &block)
-              end
+              end                                                 # end
             RUBY
           end
         end
@@ -251,7 +251,12 @@ module OpenHAB
           @autoupdate = autoupdate
           @channels = []
           @expire = nil
-          self.expire(*Array(expire)) if expire
+          if expire
+            expire = Array(expire)
+            expire_config = expire.pop if expire.last.is_a?(Hash)
+            expire_config ||= {}
+            self.expire(*expire, **expire_config)
+          end
           self.alexa(alexa) if alexa
           self.ga(ga) if ga
           self.homekit(homekit) if homekit
@@ -365,7 +370,7 @@ module OpenHAB
         #     end
         #   end
         #
-        def channel(channel, **config)
+        def channel(channel, config = {})
           @channels << [channel, config]
         end
 

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "ruby2_keywords"
+
 module OpenHAB
   module DSL
     module Items
@@ -21,6 +23,9 @@ module OpenHAB
         end
 
         # Extensions for {::GenericItem} to implement {Ensure}'s functionality
+        #
+        # @see OpenHAB::DSL.ensure ensure
+        # @see OpenHAB::DSL.ensure_states ensure_states
         module GenericItem
           include Ensurable
 
@@ -71,14 +76,13 @@ module OpenHAB
           end
 
           # activate `ensure_states` before forwarding to the wrapped object
-          def method_missing(method, *args, &block)
+          ruby2_keywords def method_missing(method, *args, &block)
             return super unless @item.respond_to?(method)
 
             DSL.ensure_states do
               @item.__send__(method, *args, &block)
             end
           end
-          ruby2_keywords :method_missing if respond_to? :ruby2_keywords
 
           # .
           def respond_to_missing?(method, include_private = false)

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

@@ -123,9 +123,9 @@ module OpenHAB
                   timed_command_details.on_expire = on_expire unless on_expire.nil?
                   timed_command_details.timer.reschedule(duration)
                   # disable the cancel rule while we send the new command
-                  Core.rule_manager.set_enabled(timed_command_details.rule_uid, false)
+                  DSL.rules[timed_command_details.rule_uid].disable
                   super(command)
-                  Core.rule_manager.set_enabled(timed_command_details.rule_uid, true)
+                  DSL.rules[timed_command_details.rule_uid].enable
                   timed_command_details
                 end
               end
@@ -145,10 +145,9 @@ module OpenHAB
 
           timed_command_details.timer = timed_command_timer(timed_command_details, duration)
           cancel_rule = TimedCommandCancelRule.new(timed_command_details)
-          timed_command_details.rule_uid = Core.automation_manager
-                                               .add_rule(cancel_rule)
-                                               .uid
-          Rules.script_rules[timed_command_details.rule_uid] = cancel_rule
+          unmanaged_rule = Core.automation_manager.add_unmanaged_rule(cancel_rule)
+          timed_command_details.rule_uid = unmanaged_rule.uid
+          Core::Rules::Provider.current.add(unmanaged_rule)
           logger.trace "Created Timed Command #{timed_command_details}"
           timed_command_details
         end
@@ -160,7 +159,7 @@ module OpenHAB
           DSL.after(duration) do
             timed_command_details.mutex.synchronize do
               logger.trace "Timed command expired - #{timed_command_details}"
-              DSL.remove_rule(timed_command_details.rule_uid)
+              DSL.rules.remove(timed_command_details.rule_uid)
               timed_command_details.resolution = :expired
               case timed_command_details.on_expire
               when Proc
@@ -200,11 +199,9 @@ module OpenHAB
               type: Rules::Triggers::Changed::ITEM_STATE_CHANGE,
               config: { "itemName" => timed_command_details.item.name }
             )]
+            self.visibility = Core::Rules::Visibility::HIDDEN
           end
 
-          # Cleanup the rule; nothing to do here.
-          def cleanup; end
-
           #
           # Execute the rule
           #
@@ -217,7 +214,7 @@ module OpenHAB
                 logger.trace "Canceling implicit timer #{@timed_command_details.timer} for "\
                              "#{@timed_command_details.item.name}  because received event #{inputs}"
                 @timed_command_details.timer.cancel
-                DSL.remove_rule(@timed_command_details.rule_uid)
+                DSL.rules.remove(@timed_command_details.rule_uid)
                 @timed_command_details.resolution = :cancelled
                 if @timed_command_details.on_expire.is_a?(Proc)
                   logger.trace "Executing user supplied block on timed command cancelation"
@@ -226,6 +223,8 @@ module OpenHAB
               end
               TimedCommand.timed_commands.delete(@timed_command_details.item)
             rescue Exception => e
+              raise if defined?(::RSpec)
+
               logger.log_exception(e)
             end
           end

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

@@ -16,7 +16,7 @@ module OpenHAB
         # @param [Config] config Rule configuration
         #
         # Constructor sets a number of variables, no further decomposition necessary
-        def initialize(config:)
+        def initialize(config)
           # Metrics disabled because only setters are called or defaults set.
           super()
           set_name(config.name)
@@ -29,8 +29,13 @@ module OpenHAB
           @guard = config.guard
           @between = config.between && DSL.between(config.between)
           @trigger_conditions = config.trigger_conditions
+          @trigger_conditions.each_value do |condition|
+            condition.rule = self if condition.respond_to?(:rule=)
+          end
           @attachments = config.attachments
           @thread_locals = ThreadLocal.persist
+          @cleanup_hooks = Set.new
+          @listener = nil
         end
 
         #
@@ -48,19 +53,37 @@ module OpenHAB
               process_queue(create_queue(inputs), mod, inputs)
             end
           rescue Exception => e
+            raise if defined?(::RSpec)
+
             @run_context.send(:logger).log_exception(e)
           end
         end
 
-        #
-        # Cleanup any resources associated with automation rule
-        #
-        def cleanup
-          @trigger_conditions.each_value(&:cleanup)
+        # @!visibility private
+        def on_removal(listener)
+          @cleanup_hooks << listener
+          listen_for_removal unless @listener
         end
 
         private
 
+        def cleanup
+          @cleanup_hooks.each(&:cleanup)
+        end
+
+        def listen_for_removal
+          @listener ||= org.openhab.core.common.registry.RegistryChangeListener.impl do |method, element|
+            next unless method == :removed
+
+            logger.trace("Rule #{element.inspect} removed from registry")
+            next unless element.uid == uid
+
+            cleanup
+            $rules.remove_registry_change_listener(@listener)
+          end
+          $rules.add_registry_change_listener(@listener)
+        end
+
         #
         # Create the run queue based on guards
         #
@@ -70,9 +93,9 @@ module OpenHAB
         def create_queue(inputs)
           case check_guards(event: extract_event(inputs))
           when true
-            @run_queue.dup.grep_v(Builder::Otherwise)
+            @run_queue.dup.grep_v(BuilderDSL::Otherwise)
           when false
-            @run_queue.dup.grep(Builder::Otherwise)
+            @run_queue.dup.grep(BuilderDSL::Otherwise)
           end
         end
 
@@ -166,7 +189,7 @@ module OpenHAB
           event = extract_event(inputs)
 
           while (task = run_queue.shift)
-            if task.is_a?(Builder::Delay)
+            if task.is_a?(BuilderDSL::Delay)
               process_delay_task(inputs, mod, run_queue, task)
             else
               process_task(event, task)
@@ -183,10 +206,10 @@ module OpenHAB
         def process_task(event, task)
           ThreadLocal.thread_local(**@thread_locals) do
             case task
-            when Builder::Run then process_run_task(event, task)
-            when Builder::Script then process_script_task(task)
-            when Builder::Trigger then process_trigger_task(event, task)
-            when Builder::Otherwise then process_otherwise_task(event, task)
+            when BuilderDSL::Run then process_run_task(event, task)
+            when BuilderDSL::Script then process_script_task(task)
+            when BuilderDSL::Trigger then process_trigger_task(event, task)
+            when BuilderDSL::Otherwise then process_otherwise_task(event, task)
             end
           end
         end

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

@@ -5,6 +5,7 @@ require "forwardable"
 require_relative "property"
 require_relative "guard"
 require_relative "rule_triggers"
+require_relative "terse"
 
 Dir[File.expand_path("triggers/*.rb", __dir__)].sort.each do |f|
   require f
@@ -16,10 +17,100 @@ module OpenHAB
     # Creates and manages OpenHAB Rules
     #
     module Rules
+      # A rules builder allows you to create OpenHAB rules.
       #
-      # Rule configuration for OpenHAB Rules engine
+      # Note that all methods on this module are also availabe directly on {OpenHAB::DSL}.
       #
       class Builder
+        include Terse
+
+        # @return [org.openhab.core.automation.RuleProvider]
+        attr_reader :provider
+
+        def initialize(provider)
+          @provider = Core::Rules::Provider.current(provider)
+        end
+
+        #
+        # Create a new rule
+        #
+        # @param [String] name The rule name
+        # @yield Block executed in the context of a {Rules::Builder}
+        # @yieldparam [Rules::Builder] rule
+        #   Optional parameter to access the rule configuration from within execution blocks and guards.
+        # @return [Rule]
+        #
+        # @see OpenHAB::DSL::Rules::Builder Rule builder for details on rule triggers, guards and execution blocks
+        # @see Rules::Terse Terse Rules
+        #
+        # @example
+        #   require "openhab/dsl"
+        #
+        #   rule "name" do
+        #     <zero or more triggers>
+        #     <zero or more execution blocks>
+        #     <zero or more guards>
+        #   end
+        #
+        def rule(name = nil, id: nil, script: nil, binding: nil, &block)
+          raise ArgumentError, "Block is required" unless block
+
+          id ||= NameInference.infer_rule_id_from_block(block)
+          script ||= block.source rescue nil # rubocop:disable Style/RescueModifier
+
+          builder = nil
+
+          ThreadLocal.thread_local(openhab_rule_type: "rule", openhab_rule_uid: id) do
+            builder = BuilderDSL.new(binding || block.binding)
+            builder.uid(id)
+            builder.instance_exec(builder, &block)
+            builder.guard = Guard.new(run_context: builder.caller, only_if: builder.only_if,
+                                      not_if: builder.not_if)
+
+            name ||= NameInference.infer_rule_name(builder)
+            name ||= id
+
+            builder.name(name)
+            logger.trace { builder.inspect }
+            builder.build(provider, script)
+          end
+        end
+
+        #
+        # Create a new script
+        #
+        # A script is a rule with no triggers. It can be called by various other actions,
+        # such as the Run Rules action.
+        #
+        # @param [String] name A descriptive name
+        # @param [String] id The script's ID
+        # @yield [] Block executed when the script is executed.
+        # @return [Rule]
+        #
+        def script(name = nil, id: nil, script: nil, &block)
+          raise ArgumentError, "Block is required" unless block
+
+          id ||= NameInference.infer_rule_id_from_block(block)
+          name ||= id
+          script ||= block.source rescue nil # rubocop:disable Style/RescueModifier
+
+          builder = nil
+          ThreadLocal.thread_local(openhab_rule_type: "script", openhab_rule_uid: id) do
+            builder = BuilderDSL.new(block.binding)
+            builder.uid(id)
+            builder.tags(["Script"])
+            builder.name(name)
+            builder.script(&block)
+            logger.trace { builder.inspect }
+            builder.build(provider, script)
+          end
+        end
+      end
+
+      #
+      # Rule configuration for OpenHAB Rules engine
+      #
+      class BuilderDSL
         include Core::EntityLookup
         include DSL
         prepend Triggers
@@ -1319,12 +1410,11 @@ module OpenHAB
         # @param [String] script The source code of the rule
         #
         # @!visibility private
-        def build(script)
+        def build(provider, script)
           return unless create_rule?
 
-          rule = AutomationRule.new(config: self)
-          added_rule = add_rule(rule)
-          Rules.script_rules[rule.uid] = rule
+          rule = AutomationRule.new(self)
+          added_rule = add_rule(provider, rule)
           # 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)
@@ -1383,8 +1473,7 @@ module OpenHAB
         #
         # @param [org.openhab.core.automation.module.script.rulesupport.shared.simple.SimpleRule] rule to add
         #
-        #
-        def add_rule(rule)
+        def add_rule(provider, rule)
           base_uid = rule.uid
           duplicate_index = 1
           while $rules.get(rule.uid)
@@ -1392,7 +1481,9 @@ module OpenHAB
             rule.uid = "#{base_uid} (#{duplicate_index})"
           end
           logger.trace("Adding rule: #{rule}")
-          Core.automation_manager.add_rule(rule)
+          unmanaged_rule = Core.automation_manager.add_unmanaged_rule(rule)
+          provider.add(unmanaged_rule)
+          unmanaged_rule
         end
       end
     end

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

@@ -23,11 +23,6 @@ module OpenHAB
         private_constant :KNOWN_TRIGGER_TYPES
 
         class << self
-          # takes a freeform rule name and makes it more palatable as an id
-          def infer_rule_id_from_name(name)
-            name.downcase.delete("'\"").gsub(/\W+/, "_")
-          end
-
           # 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)

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

@@ -26,13 +26,12 @@ module OpenHAB
           #   @param id [String] The ID for the rule.
           #   @yield The execution block for the rule.
           #   @return [void]
-          #   @see Builder#$1
+          #   @see BuilderDSL#$1
           def def_terse_rule(trigger)
             class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
               def #{trigger}(*args, name: nil, id: nil, **kwargs, &block)     # def changed(*args, name: nil, id: nil, **kwargs, &block)
                 raise ArgumentError, "Block is required" unless block         #   raise ArgumentError, "Block is required" unless block
                                                                               #
-                id ||= NameInference.infer_rule_id_from_name(name) if name    #   id ||= NameInference.infer_rule_id_from_name(name) if name
                 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
                 caller_binding = block.binding                                #   caller_binding = block.binding