openhab-jrubyscripting 5.0.0.rc1 → 5.0.0.rc2

data/lib/openhab/core/registry.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module Core
+    Registry = org.openhab.core.common.registry.AbstractRegistry
+
+    Registry.field_reader :elementToProvider, :elementReadLock, :identifierToElement
+
+    # @abstract
+    #
+    # The base class for all registries in openHAB.
+    #
+    class Registry
+      #
+      # Determines which provider an element is associated with.
+      #
+      # @param [Object] key
+      # @return [org.openhab.core.common.registry.Provider]
+      #
+      def provider_for(key)
+        elementReadLock.lock
+        return nil unless (element = identifierToElement[key])
+
+        elementToProvider[element]
+      ensure
+        elementReadLock.unlock
+      end
+    end
+  end
+end

data/lib/openhab/core/script_handling.rb

@@ -2,6 +2,56 @@
 
 module OpenHAB
   module Core
+    #
+    # Provide callback mechanisms for script handling
+    #
+    module ScriptHandling
+      module_function
+
+      #
+      # Add a block of code to be executed once the rule script has finished loading.
+      #
+      # This can occur on OpenHAB start up, when the script is first created, or updated.
+      #
+      # Multiple hooks can be added by calling {#script_loaded} multiple times.
+      # They can be used to perform final initializations.
+      #
+      # @return [void]
+      #
+      # @example
+      #   script_loaded do
+      #     logger.info 'Hi, this script has just finished loading'
+      #   end
+      #
+      # @example
+      #   script_loaded do
+      #     logger.info 'I will be called after the script finished loading too'
+      #   end
+      #
+      def script_loaded(&block)
+        Core::ScriptHandlingCallbacks.script_loaded_hooks << block
+      end
+
+      #
+      # Add a block of code to be executed when the script is unloaded.
+      #
+      # This can occur when OpenHAB shuts down, or when the script is being reloaded.
+      #
+      # Multiple hooks can be added by calling {#script_unloaded} multiple times.
+      # They can be used to perform final cleanup.
+      #
+      # @return [void]
+      #
+      # @example
+      #   script_unloaded do
+      #     logger.info 'Hi, this script has been unloaded'
+      #   end
+      #
+      def script_unloaded(&block)
+        Core::ScriptHandlingCallbacks.script_unloaded_hooks << block
+      end
+    end
+
     #
     # Manages script loading and unloading
     #

data/lib/openhab/core/things/links/provider.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module Core
+    module Things
+      #
+      # Contains the link between a {Thing Thing's} {Channel Channels} and {GenericItem Items}.
+      #
+      module Links
+        #
+        # Provides {Items::GenericItem items} linked to {Channel channels} in Ruby to openHAB.
+        #
+        class Provider < Core::Provider
+          include org.openhab.core.thing.link.ItemChannelLinkProvider
+
+          class << self
+            #
+            # The ItemChannelLink registry
+            #
+            # @return [org.openhab.core.thing.link.ItemChanneLinkRegistry]
+            #
+            def registry
+              @registry ||= OSGi.service("org.openhab.core.thing.link.ItemChannelLinkRegistry")
+            end
+
+            # @!visibility private
+            def link(item, channel, config = {})
+              config = org.openhab.core.config.core.Configuration.new(config.transform_keys(&:to_s))
+              channel = ChannelUID.new(channel) if channel.is_a?(String)
+              channel = channel.uid if channel.is_a?(Channel)
+              link = org.openhab.core.thing.link.ItemChannelLink.new(item.name, channel, config)
+
+              current.add(link)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module Core
+    module Things
+      #
+      # Provides {Thing Things} created in Ruby to openHAB
+      #
+      class Provider < Core::Provider
+        include org.openhab.core.thing.ThingProvider
+
+        class << self
+          #
+          # The Thing registry
+          #
+          # @return [org.openhab.core.thing.ThingRegistry]
+          #
+          def registry
+            $things
+          end
+        end
+      end
+    end
+  end
+end

data/lib/openhab/core/things/proxy.rb

@@ -63,6 +63,16 @@ module OpenHAB
 
           super
         end
+
+        #
+        # Non equality comparison
+        #
+        # @return [true, false]
+        #
+        # @!visibility private
+        def !=(other)
+          !(self == other) # rubocop:disable Style/InverseMethods
+        end
       end
     end
   end

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

@@ -24,6 +24,8 @@ module OpenHAB
         end
         alias_method :include?, :[]
         alias_method :key?, :[]
+        # @deprecated
+        alias_method :has_key?, :[]
 
         #
         # Explicit conversion to array
@@ -34,11 +36,32 @@ module OpenHAB
           $things.all.map { |thing| Proxy.new(thing) }
         end
 
+        #
         # Enter the Thing Builder DSL.
+        # @param (see Core::Provider.current)
         # @yield Block executed in the context of a {DSL::Things::Builder}.
         # @return [Object] The result of the block.
-        def build(&block)
-          DSL::Things::Builder.new.instance_eval(&block)
+        #
+        def build(preferred_provider = nil, &block)
+          DSL::Things::Builder.new(preferred_provider).instance_eval(&block)
+        end
+
+        #
+        # Remove a Thing.
+        #
+        # The thing must be a managed thing (typically created by Ruby or in the UI).
+        #
+        # @param [String, Thing, ThingUID] thing_uid
+        # @return [Thing, nil] The removed item, if found.
+        def remove(thing_uid)
+          thing_uid = thing.uid if thing_uid.is_a?(Thing)
+          thing_uid = ThingUID.new(thing_uid) if thing_uid.is_a?(String)
+          provider = Provider.registry.provider_for(thing_uid)
+          unless provider.is_a?(org.openhab.core.common.registry.ManagedProvider)
+            raise "Cannot remove thing #{thing_uid} from non-managed provider #{provider.inspect}"
+          end
+
+          provider.remove(thing_uid)
         end
       end
     end

data/lib/openhab/core/timer.rb

@@ -96,6 +96,18 @@ module OpenHAB
       #
       def cancel
         DSL.timers.delete(self)
+        cancel!
+      end
+
+      #
+      # Cancel the timer but do not remove self from the timer manager
+      #
+      # To be used internally by {TimerManager} from inside ConcurrentHashMap's compute blocks
+      #
+      # @return [true,false] True if cancel was successful, false otherwise
+      #
+      # @!visibility private
+      def cancel!
         @timer.cancel
       end
 

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

@@ -15,6 +15,9 @@ module OpenHAB
       # framework in OpenHAB. It is represented as a decimal number with a unit.
       # You can construct a {QuantityType} object by using the pipe operator with any Numeric.
       #
+      # @see OpenHAB::DSL.unit unit: Implicit unit conversions
+      # @see OpenHAB::CoreExt::Ruby::QuantityTypeConversion Convert Numeric to QuantityType
+      #
       # @example QuantityTypes can perform math operations between them.
       #   (50 | "°F") + (-25 | "°F") # => 25.0 °F
       #   (100 | "°F") / (2 | "°F") # => 50
@@ -141,7 +144,7 @@ module OpenHAB
               return compare_to(QuantityType.new(other, unit))
             end
 
-            return nil # don"t allow comparison with numeric outside a unit block
+            return nil # don't allow comparison with numeric outside a unit block
           end
 
           return nil unless other.respond_to?(:coerce)
@@ -308,7 +311,7 @@ module OpenHAB
         def multiply_quantity(other)
           lhs = deunitize
           rhs = other.deunitize
-          # reverse the arguments if it's multiplication and the LHS isn"t a QuantityType
+          # reverse the arguments if it's multiplication and the LHS isn't a QuantityType
           lhs, rhs = rhs, lhs if lhs.is_a?(java.math.BigDecimal)
           # what a waste... using a QuantityType to multiply two dimensionless quantities
           # have to make sure lhs is still a QuantityType in order to return a new

data/lib/openhab/core.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+# several classes rely on this, so force it to load earlier
+require_relative "core/provider"
+
 Dir[File.expand_path("core/**/*.rb", __dir__)].sort.each do |f|
   require f
 end
@@ -42,20 +45,6 @@ module OpenHAB
         Pathname.new(org.openhab.core.OpenHAB.config_folder)
       end
 
-      #
-      # JRuby isn't respecting $RUBYLIB when run embedded inside of OpenHAB, so do it manually
-      #
-      # @return [void]
-      #
-      # @!visibility private
-      def add_rubylib_to_load_path
-        ENV["RUBYLIB"]&.split(File::PATH_SEPARATOR)&.each do |path|
-          next if path.empty?
-
-          $LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)
-        end
-      end
-
       #
       # @!attribute [r] automation_manager
       # @return [org.openhab.core.automation.module.script.rulesupport.shared.ScriptedAutomationManager]

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module CoreExt
+    module Java
+      Class = java.lang.Class
+
+      # Extensions to Class
+      class Class
+        #
+        # `self`, all superclasses and interfaces, recursively.
+        #
+        # @return [Array<Class>]
+        #
+        def ancestors
+          ([self] +
+            Array(superclass&.ancestors) +
+            interfaces.flat_map(&:ancestors)).uniq
+        end
+
+        #
+        # `self`, all superclasses and interfaces, recursively.
+        #
+        # @return [Array<java.reflect.Type>]
+        #
+        def generic_ancestors
+          ancestors.flat_map do |klass|
+            Array(klass.generic_superclass) + klass.generic_interfaces
+          end.uniq
+        end
+      end
+    end
+  end
+end

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

@@ -33,7 +33,7 @@ module OpenHAB
       #   end
       #
       class LocalTime
-        include Time
+        # @!parse include Time
 
         # @!visibility private
         class << self
@@ -104,3 +104,4 @@ module OpenHAB
 end
 
 LocalTime = OpenHAB::CoreExt::Java::LocalTime unless Object.const_defined?(:LocalTime)
+java.time.LocalTime.include(OpenHAB::CoreExt::Java::Time)

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/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.
@@ -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
 

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

@@ -703,6 +703,16 @@ module OpenHAB
 
           @ruby_triggers << [:changed, items, { to: to, from: from, duration: duration }]
           items.each do |item|
+            case item
+            when Core::Things::Thing,
+                 Core::Things::ThingUID,
+                 Core::Items::GenericItem,
+                 Core::Items::GroupItem::Members
+              nil
+            else
+              raise ArgumentError, "items must be a GenericItem, GroupItem::Members, Thing, or ThingUID"
+            end
+
             logger.trace("Creating changed trigger for entity(#{item}), to(#{to.inspect}), from(#{from.inspect})")
 
             Array.wrap(from).each do |from_state|
@@ -970,6 +980,13 @@ module OpenHAB
           @ruby_triggers << [:received_command, items, { command: commands }]
 
           items.each do |item|
+            case item
+            when Core::Items::GenericItem,
+                 Core::Items::GroupItem::Members
+              nil
+            else
+              raise ArgumentError, "items must be a GenericItem or GroupItem::Members"
+            end
             commands.each do |cmd|
               logger.trace "Creating received command trigger for items #{item.inspect} and commands #{cmd.inspect}"
 
@@ -1160,6 +1177,16 @@ module OpenHAB
           updated = Updated.new(rule_triggers: @rule_triggers)
           @ruby_triggers << [:updated, items, { to: to }]
           items.map do |item|
+            case item
+            when Core::Things::Thing,
+                 Core::Things::ThingUID,
+                 Core::Items::GenericItem,
+                 Core::Items::GroupItem::Members
+              nil
+            else
+              raise ArgumentError, "items must be a GenericItem, GroupItem::Members, Thing, or ThingUID"
+            end
+
             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/rules/triggers/changed.rb

@@ -107,10 +107,13 @@ module OpenHAB
           #
           def changed_trigger(item:, from:, to:, attach: nil, conditions: nil)
             type, config = case item
-                           when GroupItem::Members then group(group: item, from: from,
-                                                              to: to)
-                           when Core::Things::Thing then thing(thing: item, from: from, to: to)
-                           else item(item: item, from: from, to: to)
+                           when GroupItem::Members
+                             group(group: item, from: from, to: to)
+                           when Core::Things::Thing,
+                                Core::Things::ThingUID
+                             thing(thing: item, from: from, to: to)
+                           else
+                             item(item: item, from: from, to: to)
                            end
             append_trigger(type: type, config: config, attach: attach, conditions: conditions)
           end

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

@@ -11,7 +11,7 @@ module OpenHAB
         # Creates cron triggers
         #
         class Cron < Trigger
-          # Trigger ID for Watch Triggers
+          # Trigger ID for Cron Triggers
           CRON_TRIGGER_MODULE_ID = "jsr223.jruby.CronTrigger"
 
           #

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

@@ -33,7 +33,7 @@ module OpenHAB
           # @return [Array] Trigger and config for thing
           #
           def trigger_for_thing(thing:, type:, to: nil, from: nil)
-            config = { "thingUID" => thing.uid.to_s }
+            config = { "thingUID" => thing.to_s }
             config["status"] = trigger_state_from_symbol(to).to_s if to
             config["previousStatus"] = trigger_state_from_symbol(from).to_s if from
             [type, config]

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

@@ -74,9 +74,13 @@ module OpenHAB
           #
           def update_trigger(item:, to:, attach: nil, conditions: nil)
             type, config = case item
-                           when GroupItem::Members then group_update(item: item, to: to)
-                           when Core::Things::Thing then thing_update(thing: item, to: to)
-                           else item_update(item: item, to: to)
+                           when GroupItem::Members
+                             group_update(item: item, to: to)
+                           when Core::Things::Thing,
+                                Core::Things::ThingUID
+                             thing_update(thing: item, to: to)
+                           else
+                             item_update(item: item, to: to)
                            end
             append_trigger(type: type, config: config, attach: attach, conditions: conditions)
           end

data/lib/openhab/dsl/rules.rb

@@ -23,7 +23,7 @@ module OpenHAB
           script_rules.each_value(&:cleanup)
         end
       end
-      ScriptHandling.script_unloaded { cleanup_rules }
+      Core::ScriptHandling.script_unloaded { cleanup_rules }
     end
   end
 end

data/lib/openhab/dsl/script_handling.rb

@@ -2,54 +2,5 @@
 
 module OpenHAB
   module DSL
-    #
-    # Provide callback mechanisms for script handling
-    #
-    module ScriptHandling
-      module_function
-
-      #
-      # Add a block of code to be executed once the rule script has finished loading.
-      #
-      # This can occur on OpenHAB start up, when the script is first created, or updated.
-      #
-      # Multiple hooks can be added by calling {#script_loaded} multiple times.
-      # They can be used to perform final initializations.
-      #
-      # @return [void]
-      #
-      # @example
-      #   script_loaded do
-      #     logger.info 'Hi, this script has just finished loading'
-      #   end
-      #
-      # @example
-      #   script_loaded do
-      #     logger.info 'I will be called after the script finished loading too'
-      #   end
-      #
-      def script_loaded(&block)
-        Core::ScriptHandlingCallbacks.script_loaded_hooks << block
-      end
-
-      #
-      # Add a block of code to be executed when the script is unloaded.
-      #
-      # This can occur when OpenHAB shuts down, or when the script is being reloaded.
-      #
-      # Multiple hooks can be added by calling {#script_unloaded} multiple times.
-      # They can be used to perform final cleanup.
-      #
-      # @return [void]
-      #
-      # @example
-      #   script_unloaded do
-      #     logger.info 'Hi, this script has been unloaded'
-      #   end
-      #
-      def script_unloaded(&block)
-        Core::ScriptHandlingCallbacks.script_unloaded_hooks << block
-      end
-    end
   end
 end