openhab-jrubyscripting 5.0.0.rc1 → 5.0.0.rc3

data/lib/openhab/core_ext/java/map.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+# @!visibility private
+module Java::JavaUtil::Map # rubocop:disable Style/ClassAndModuleChildren
+  def compact
+    reject { |_k, v| v.nil? }
+  end
+
+  def compact!
+    reject! { |_k, v| v.nil? }
+    self
+  end
+
+  def deconstruct_keys
+    self
+  end
+
+  def except(*keys)
+    reject { |k, _v| keys.include?(k) }
+  end
+
+  def slice(*keys)
+    select { |k, _v| keys.include?(k) }
+  end
+
+  def transform_keys(hash2 = nil)
+    raise NotImplementedError unless hash2 || block_given?
+
+    map do |k, v| # rubocop:disable Style/MapToHash
+      if hash2&.key?(k)
+        [hash2[k], v]
+      elsif block_given?
+        [(yield k), v]
+      else
+        [k, v]
+      end
+    end.to_h
+  end
+
+  def transform_keys!(hash2 = nil)
+    raise NotImplementedError unless hash2 || block_given?
+
+    keys.each do |k|
+      if hash2&.key?(k)
+        self[hash2[k]] = delete(k)
+      elsif block_given?
+        new_k = yield k
+        self[new_k] = delete(k) unless new_k == k
+      end
+    end
+    self
+  end
+
+  def transform_values
+    map do |k, v| # rubocop:disable Style/MapToHash, Style/HashTransformValues
+      [k, (yield v)]
+    end.to_h
+  end
+
+  def transform_values!
+    replace_all do |_k, v|
+      yield v
+    end
+    self
+  end
+end

data/lib/openhab/core_ext/java/month.rb

@@ -9,7 +9,7 @@ module OpenHAB
 
       # Extensions to Month
       class Month
-        include Time
+        # @!parse include Time
 
         #
         # Returns the next month
@@ -57,3 +57,4 @@ module OpenHAB
 end
 
 Month = OpenHAB::CoreExt::Java::Month unless Object.const_defined?(:Month)
+java.time.Month.include(OpenHAB::CoreExt::Java::Time)

data/lib/openhab/core_ext/java/zoned_date_time.rb

@@ -25,8 +25,7 @@ module OpenHAB
         # @return [ZonedDateTime] If other is a TemporalAmount
         def -(other)
           if other.respond_to?(:to_zoned_date_time)
-            nanos = other.to_zoned_date_time.until(self, java.time.temporal.ChronoUnit::NANOS)
-            (nanos.to_f / 1_000_000_000).seconds
+            java.time.Duration.between(other.to_zoned_date_time, self)
           elsif other.is_a?(Numeric)
             minus(other.seconds)
           else

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "date"
+
 # Extensions to Date
 class Date
   #

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "date"
+require "forwardable"
+
+# DateTime inherits from Date, but is more similar to Time semantically.
+# So it avoid alias_method chain bombs, and to ensure the correct end methods
+# exist here, we define the important methods from Time here as well.
+
+# Extensions to DateTime
+class DateTime < Date
+  extend Forwardable
+
+  # (see Time#plus_with_temporal)
+  def plus_with_temporal(other)
+    return to_zoned_date_time + other if other.is_a?(java.time.temporal.TemporalAmount)
+
+    plus_without_temporal(other)
+  end
+  # alias_method :plus_without_temporal, :+ # already done by Date
+  alias_method :+, :plus_with_temporal
+
+  # (see Time#minus_with_temporal)
+  def minus_with_temporal(other)
+    return to_zoned_date_time - other if other.is_a?(java.time.temporal.TemporalAmount)
+
+    # 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
+
+    minus_without_temporal(other)
+  end
+  # alias_method :minus_without_temporal, :- # already done by Date
+  alias_method :-, :minus_with_temporal
+
+  # @!method to_local_time
+  #   @return [LocalTime]
+  def_delegator :to_zoned_date_time, :to_local_time
+
+  # (see Time#to_zoned_date_time)
+  def to_zoned_date_time(context = nil) # rubocop:disable Lint/UnusedMethodArgument
+    to_java(ZonedDateTime)
+  end
+
+  # (see Time#coerce)
+  def coerce(other)
+    return unless other.respond_to?(:to_zoned_date_time)
+
+    zdt = to_zoned_date_time
+    [other.to_zoned_date_time(zdt), zdt]
+  end
+end

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

@@ -6,100 +6,6 @@ module OpenHAB
     # Contains extensions to simplify working with [GenericItem]s.
     #
     module Items
-      # Stores all items created in scripts, and notifies the ItemRegistry
-      # of their existence
-      # @!visibility private
-      class ItemProvider < org.openhab.core.common.registry.AbstractProvider
-        include org.openhab.core.items.ItemProvider
-        include Singleton
-
-        def initialize
-          super
-
-          @items = {}
-
-          $ir.add_provider(self)
-          ScriptHandling.script_unloaded { $ir.remove_provider(self) }
-        end
-
-        # Add an item to this provider
-        def add(builder)
-          item = builder.build
-          raise "Item #{item.name} already exists" if @items.key?(item.name)
-
-          @items[item.name] = item
-          notify_listeners_about_added_element(item)
-
-          # make sure to add the item to the registry before linking it
-          builder.channels.each do |(channel, config)|
-            if !channel.include?(":") &&
-               (group = builder.groups.find { |g| g.is_a?(GroupItemBuilder) && g.thing })
-              thing = group.thing
-              thing = thing.uid if thing.is_a?(Core::Things::Thing)
-              channel = "#{thing}:#{channel}"
-            end
-            ItemChannelLinkProvider.instance.link(item, channel, config)
-          end
-
-          item
-        end
-
-        # Remove an item from this provider
-        #
-        # @return [GenericItem, nil] The removed item, if found.
-        def remove(item_name, recursive: false)
-          return nil unless @items.key?(item_name)
-
-          item = @items.delete(item_name)
-          if recursive && item.is_a?(Core::Items::GroupItem)
-            item.members.each { |member| remove(member.__getobj__, recursive: true) }
-          end
-
-          notify_listeners_about_removed_element(item)
-          item
-        end
-
-        # Get all items in this provider
-        def getAll # rubocop:disable Naming/MethodName required by java interface
-          @items.values
-        end
-      end
-
-      # @!visibility private
-      class ItemChannelLinkProvider < org.openhab.core.common.registry.AbstractProvider
-        include org.openhab.core.thing.link.ItemChannelLinkProvider
-        include Singleton
-
-        def initialize
-          super
-
-          @links = Hash.new { |h, k| h[k] = Set.new }
-          registry = OSGi.service("org.openhab.core.thing.link.ItemChannelLinkRegistry")
-          registry.add_provider(self)
-          ScriptHandling.script_unloaded { registry.remove_provider(self) }
-        end
-
-        # @!visibility private
-        def link(item, channel, config = {})
-          config = org.openhab.core.config.core.Configuration.new(config.transform_keys(&:to_s))
-          channel = org.openhab.core.thing.ChannelUID.new(channel) if channel.is_a?(String)
-          channel = channel.uid if channel.is_a?(org.openhab.core.thing.Channel)
-          link = org.openhab.core.thing.link.ItemChannelLink.new(item.name, channel, config)
-
-          item_links = @links[item.name]
-          if item_links.include?(link)
-            notify_listeners_about_updated_element(link, link)
-          else
-            item_links << link
-            notify_listeners_about_added_element(link)
-          end
-        end
-
-        def getAll # rubocop:disable Naming/MethodName required by java interface
-          @links.values.flatten
-        end
-      end
-
       # An item builder allows you to dynamically create OpenHAB items at runtime.
       # This can be useful either to create items as soon as the script loads,
       # or even later based on a rule executing.
@@ -134,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
@@ -196,10 +102,37 @@ module OpenHAB
       class BaseBuilderDSL
         include Builder
 
-        private
+        # @!visibility private
+        class ProviderWrapper
+          attr_reader :provider
 
-        def provider
-          ItemProvider.instance
+          def initialize(provider)
+            @provider = provider
+          end
+
+          # @!visibility private
+          def add(builder)
+            item = builder.build
+            provider.add(item)
+            # make sure to add the item to the registry before linking it
+            builder.channels.each do |(channel, config)|
+              if !channel.include?(":") &&
+                 (group = builder.groups.find { |g| g.is_a?(GroupItemBuilder) && g.thing })
+                thing = group.thing
+                channel = "#{thing}:#{channel}"
+              end
+              Core::Things::Links::Provider.link(item, channel, config)
+            end
+            item
+          end
+        end
+        private_constant :ProviderWrapper
+
+        # @return [org.openhab.core.items.ItemProvider]
+        attr_reader :provider
+
+        def initialize(provider)
+          @provider = ProviderWrapper.new(Core::Items::Provider.current(provider))
         end
       end
 
@@ -318,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
@@ -432,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