openhab-jrubyscripting 5.0.0.rc2 → 5.0.0.rc3

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