openhab-jrubyscripting 5.0.0.rc1 → 5.0.0.rc3

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

@@ -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
@@ -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
 
@@ -107,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/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/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

@@ -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]
@@ -64,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

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/list.rb

@@ -0,0 +1,436 @@
+# frozen_string_literal: true
+
+# @!visibility private
+module Java::JavaUtil::List # rubocop:disable Style/ClassAndModuleChildren
+  extend Forwardable
+
+  def_delegators :to_a,
+                 :&,
+                 :*,
+                 :|,
+                 :bsearch_index,
+                 :difference,
+                 :flatten,
+                 :intersection,
+                 :pack,
+                 :product,
+                 :repeated_combination,
+                 :repeated_permutation,
+                 :reverse,
+                 :rotate,
+                 :sample,
+                 :shelljoin,
+                 :shuffle,
+                 :transpose,
+                 :union
+
+  def assoc(obj)
+    find { |v| (v.is_a?(Array) || v.is_a?(self.class)) && v[0] == obj }
+  end
+
+  def at(index)
+    self[index]
+  end
+
+  def bsearch(&block)
+    raise NotImplementedError unless block
+
+    r = bsearch_index(&block)
+    self[r] if r
+  end
+
+  def combination(n, &block) # rubocop:disable Naming/MethodParameterName
+    r = to_a.combination(n, &block)
+    block ? self : r
+  end
+
+  def compact
+    reject(&:nil?)
+  end
+
+  def compact!
+    reject!(&:nil?)
+  end
+
+  def concat(*other_arrays)
+    other_arrays.each { |array| add_all(array) }
+    self
+  end
+
+  def deconstruct
+    self
+  end
+
+  def delete(obj)
+    last = nil
+    found = false
+    loop do
+      i = index(obj)
+      break if i.nil?
+
+      found = true
+      last = remove(i)
+    end
+
+    return yield(obj) if !found && block_given?
+
+    last
+  end
+
+  def delete_at(index)
+    index = length + index if index.negative?
+    return if index.negative? || index >= length
+
+    remove(index)
+  end
+
+  def delete_if
+    raise NotImplementedError unless block_given?
+
+    it = list_iterator
+    while it.has_next? # rubocop:disable Style/WhileUntilModifier
+      it.remove if yield(it.next)
+    end
+    self
+  end
+
+  def dig(index, *identifiers)
+    return self[index] if identifiers.empty?
+
+    self[index]&.dig(*identifiers)
+  end
+
+  def each_index(&block)
+    r = (0...length)
+    return r.each unless block
+
+    r.each(&block)
+    self
+  end
+
+  def fetch(index, *default_value)
+    if default_value.length > 1
+      raise ArgumentError,
+            "wrong number of arguments calling `fetch` (given #{default_value.length - 1}, expected 1..2)"
+    end
+
+    original_index = index
+    index = length + index if index.negative?
+    return self[index] if index >= 0 && index < length
+
+    return default_value.first unless default_value.empty?
+    return yield(original_index) if block_given?
+
+    raise IndexError, "index #{index} out of list"
+  end
+
+  def fill(*args)
+    if block_given?
+      unless (0..2).cover?(args.length)
+        raise ArgumentError,
+              "wrong number of arguments calling `fill` (given #{args.length}, expected 1..3)"
+      end
+    else
+      unless (1..3).cover?(args.length)
+        raise ArgumentError,
+              "wrong number of arguments calling `fill` (given #{args.length}, expected 1..2)"
+      end
+    end
+
+    obj = args.shift unless block_given?
+
+    if args.length == 1 && args.first.is_a?(Range)
+      range = args.first
+
+      range = Range.new(length + range.begin, range.end, range.exclude_end?) if range.begin.negative?
+      range = Range.new(range.begin, length + range.end, range.exclude_end?) if range.end&.negative?
+      return self if range.begin.negative? || (range.end && range.end < range.begin)
+    else
+      first, count = *args
+      return self if count&.negative?
+
+      first ||= 0
+
+      first = length + first if first.negative?
+      range = count ? first...(first + count) : first..
+    end
+
+    add(nil) while length < range.begin && count
+
+    start = range.begin
+    start = 0 if start.negative?
+    start = length if start > length
+    it = list_iterator(start)
+
+    while range.cover?(it.next_index)
+      break if range.end.nil? && !it.has_next?
+
+      obj = yield(it.next_index) if block_given?
+      if it.has_next?
+        it.next
+        it.set(obj)
+      else
+        it.add(obj)
+      end
+    end
+
+    self
+  end
+
+  def flatten!(*args)
+    if args.length > 1
+      raise ArgumentError,
+            "wrong number of arguments calling `flatten` (given #{args.length}, expect 0..1)"
+    end
+
+    it = list_iterator
+
+    args = [args.first - 1] unless args.empty?
+    done = args.first == 0 # rubocop:disable Style/NumericPredicate
+
+    changed = false
+    while it.has_next?
+      element = it.next
+      next unless element.respond_to?(:to_ary)
+
+      changed = true
+      it.remove
+      arr = element.to_ary
+      arr = arr.flatten(*args) unless done
+      arr.each do |e|
+        it.add(e)
+      end
+    end
+    changed ? self : nil
+  end
+
+  def insert(index, *objects)
+    return self if objects.empty?
+
+    raise IndexError, "index #{index} too small for list, minimum: #{-length}" if index < -length
+
+    index = length + index + 1 if index.negative?
+
+    add(nil) while length < index
+    add_all(index, objects)
+    self
+  end
+
+  def intersect?(other_ary)
+    !(self & other_ary).empty?
+  end
+
+  def keep_if?
+    raise NotImplementedError unless block_given?
+
+    it = list_iterator
+    while it.has_next? # rubocop:disable Style/WhileUntilModifier
+      it.remove unless yield(it.next)
+    end
+    self
+  end
+
+  def map!(&block)
+    raise NotImplementedError unless block
+
+    replace_all(&block)
+    self
+  end
+
+  def permutation(n, &block) # rubocop:disable Naming/MethodParameterName
+    r = to_a.permutation(n, &block)
+    block ? self : r
+  end
+
+  def pop(*args)
+    if args.length > 1
+      raise ArgumentError,
+            "wrong number of arguments calling `pop` (given #{args.length}, expected 0..1)"
+    end
+
+    if args.empty?
+      return if empty?
+
+      return remove(length - 1)
+    end
+
+    count = args.first
+    start = [length - count, 0].max
+    result = self[start..-1].to_a # rubocop:disable Style/SlicingWithRange
+    it = list_iterator(start)
+    while it.has_next?
+      it.next
+      it.remove
+    end
+    result
+  end
+
+  def push(*objects)
+    add_all(objects)
+    self
+  end
+  alias_method :append, :push
+
+  def rassoc(obj)
+    find { |v| (v.is_a?(Array) || v.is_a?(self.class)) && v[1] == obj }
+  end
+
+  def reject!
+    raise NotImplementedError unless block_given?
+
+    it = list_iterator
+    changed = false
+    while it.has_next
+      if yield(it.next)
+        changed = true
+        it.remove
+      end
+    end
+    self if changed
+  end
+
+  def repeated_combination(n, &block) # rubocop:disable Naming/MethodParameterName
+    r = to_a.repeated_combination(n, &block)
+    block ? self : r
+  end
+
+  def repeated_permutation(n, &block) # rubocop:disable Naming/MethodParameterName
+    r = to_a.repeated_permutation(n, &block)
+    block ? self : r
+  end
+
+  def replace(other_array)
+    clear
+    add_all(other_array)
+    self
+  end
+
+  def reverse!
+    replace(reverse)
+    self
+  end
+
+  def rotate!(count = 1)
+    count = count % length
+    push(*shift(count))
+    self
+  end
+
+  def select!
+    raise NotImplementedError unless block_given?
+
+    it = list_iterator
+    changed = false
+    while it.has_next?
+      unless yield(it.next)
+        changed = true
+        it.remove
+      end
+    end
+    self if changed
+  end
+
+  def shift(*args)
+    if args.length > 1
+      raise ArgumentError,
+            "wrong number of arguments calling `shift` (given #{args.length}, expected 0..1)"
+    end
+
+    if args.empty?
+      return if empty?
+
+      return remove(0)
+    end
+
+    count = args.first
+    result = self[0...count].to_a
+    it = list_iterator
+    count.times do
+      break unless it.has_next?
+
+      it.next
+      it.remove
+    end
+    result
+  end
+
+  def shuffle!(*args)
+    replace(shuffle(*args))
+  end
+
+  def slice(*args)
+    self[*args]
+  end
+
+  def slice!(*args)
+    unless (1..2).cover?(args.length)
+      raise ArgumentError,
+            "wrong number of arguments calling `slice!` (given #{args.length}, expected 1..2)"
+    end
+
+    return delete_at(args.first) if args.length == 1 && !args.first.is_a?(Range)
+
+    start = args.first
+    start = start.begin if start.is_a?(Range)
+    start = length + start if start.negative?
+    return nil if start.negative? || start >= length
+
+    result = slice(*args).to_a
+
+    it = list_iterator(start)
+    result.length.times do
+      it.next
+      it.remove
+    end
+    result
+  end
+
+  def sort_by!
+    raise NotImplementedError unless block_given?
+
+    sort { |a, b| (yield a) <=> (yield b) }
+    self
+  end
+
+  def uniq!
+    seen = Set.new
+
+    it = list_iterator
+    changed = false
+    while it.has_next?
+      n = it.next
+      n = yield(n) if block_given?
+      if seen.include?(n)
+        changed = true
+        it.remove
+      end
+      seen << n
+    end
+    self if changed
+  end
+
+  def unshift(*objects)
+    add_all(0, objects)
+    self
+  end
+  alias_method :prepend, :unshift
+
+  def values_at(*indexes)
+    result = []
+    indexes.each do |index|
+      if index.is_a?(Range)
+        partial_result = self[index]
+        result.concat(partial_result)
+        result.fill(nil, result.length, index.count - partial_result.length)
+      else
+        index = length + index if index.negative?
+        result << if index.negative? || index >= length
+                    nil
+                  else
+                    self[index]
+                  end
+      end
+    end
+    result
+  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)