openhab-scripting 2.14.0 → 2.16.0

data/lib/openhab/core/dsl/items/string_item.rb

@@ -15,6 +15,7 @@ module OpenHAB
           extend Forwardable
           include Comparable
 
+          # @return [Regex] Regular expression matching blank strings
           BLANK_RE = /\A[[:space:]]*\z/.freeze
           private_constant :BLANK_RE
 
@@ -33,7 +34,8 @@ module OpenHAB
           #
           # Convert the StringItem into a String
           #
-          # @return [String] String representation of the StringItem or nil if underlying OpenHAB StringItem does not have a state
+          # @return [String] String representation of the StringItem or
+          #   nil if underlying OpenHAB StringItem does not have a state
           #
           def to_str
             @string_item.state&.to_full_string&.to_s
@@ -64,7 +66,8 @@ module OpenHAB
           #
           # @param [Object] other object to compare to
           #
-          # @return [Integer] -1,0,1 or nil depending on value supplied, nil comparison to supplied object is not possible.
+          # @return [Integer] -1,0,1 or nil depending on value supplied,
+          #   nil comparison to supplied object is not possible.
           #
           def <=>(other)
             case other
@@ -72,6 +75,8 @@ module OpenHAB
               @string_item.state <=> other.state
             when String
               @string_item.state.to_s <=> other
+            else
+              @string_item.state <=> other
             end
           end
 
@@ -87,7 +92,7 @@ module OpenHAB
           def method_missing(meth, *args, &block)
             if @string_item.respond_to?(meth)
               @string_item.__send__(meth, *args, &block)
-            elsif @string_item.state? && @string_item.state.to_full_string.to_s.respond_to?(meth)
+            elsif @string_item.state&.to_full_string&.to_s.respond_to?(meth)
               @string_item.state.to_full_string.to_s.__send__(meth, *args, &block)
             elsif ::Kernel.method_defined?(meth) || ::Kernel.private_method_defined?(meth)
               ::Kernel.instance_method(meth).bind_call(self, *args, &block)
@@ -95,6 +100,21 @@ module OpenHAB
               super(meth, *args, &block)
             end
           end
+
+          #
+          # Checks if this method responds to the missing method
+          #
+          # @param [String] method_name Name of the method to check
+          # @param [Boolean] _include_private boolean if private methods should be checked
+          #
+          # @return [Boolean] true if this object will respond to the supplied method, false otherwise
+          #
+          def respond_to_missing?(method_name, _include_private = false)
+            @string_item.respond_to?(method_name) ||
+              @string_item.state&.to_full_string&.to_s.respond_to?(method_name) ||
+              ::Kernel.method_defined?(method_name) ||
+              ::Kernel.private_method_defined?(method_name)
+          end
         end
       end
     end

data/lib/openhab/core/dsl/monkey_patch/items/dimmer_item.rb

@@ -96,12 +96,27 @@ class Java::OrgOpenhabCoreLibraryItems::DimmerItem
   def <=>(other)
     logger.trace("Comparing #{self} to #{other}")
     case other
-    when DimmerItem, NumberItem
-      state <=> other.state
-    when DecimalType
-      state <=> other
+    when Java::OrgOpenhabCoreItems::GenericItem, NumberItem then state <=> other.state
+    when DecimalType then state <=> other
+    when Numeric then state.to_big_decimal.to_d <=> other.to_d
+    else compare_to(other)
+    end
+  end
+
+  #
+  # Coerce objects into a DimmerItem
+  #
+  # @param [Object] other object to coerce to a DimmerItem if possible
+  #
+  # @return [Object] Numeric when applicable
+  #
+  def coerce(other)
+    logger.trace("Coercing #{self} as a request from  #{other.class}")
+    case other
+    when Numeric
+      [other, state.to_big_decimal.to_d]
     else
-      to_i <=> other.to_i
+      [other, state]
     end
   end
 

data/lib/openhab/core/dsl/monkey_patch/items/items.rb

@@ -6,6 +6,7 @@ require 'bigdecimal'
 
 # Monkey patch items
 require 'openhab/core/dsl/monkey_patch/items/metadata'
+require 'openhab/core/dsl/monkey_patch/items/persistence'
 require 'openhab/core/dsl/monkey_patch/items/contact_item'
 require 'openhab/core/dsl/monkey_patch/items/dimmer_item'
 require 'openhab/core/dsl/monkey_patch/items/switch_item'
@@ -127,4 +128,5 @@ class Java::OrgOpenhabCoreItems::GenericItem
   # rubocop:enable Style/ClassAndModuleChildren
   prepend OpenHAB::Core::DSL::MonkeyPatch::Items::ItemExtensions
   prepend OpenHAB::Core::DSL::MonkeyPatch::Items::Metadata
+  prepend OpenHAB::Core::DSL::MonkeyPatch::Items::Persistence
 end

data/lib/openhab/core/dsl/monkey_patch/items/metadata.rb

@@ -123,25 +123,7 @@ module OpenHAB
               # @return [OpenHAB::Core::DSL::MonkeyPatch::Items::MetadataItem]
               #
               def []=(namespace, value)
-                case value
-                when MetadataItem
-                  meta_value = value.value
-                  configuration = value.__getobj__
-                when Metadata
-                  meta_value = value.value
-                  configuration = value.configuration
-                when Array
-                  raise ArgumentError, 'Array must contain 2 elements: value, config' if value.length < 2
-
-                  meta_value = value[0]
-                  configuration = value[1]
-                when Hash
-                  meta_value = nil
-                  configuration = value
-                else
-                  meta_value = value
-                  configuration = nil
-                end
+                meta_value, configuration = update_from_value(value)
 
                 key = MetadataKey.new(namespace, @item_name)
                 metadata = Metadata.new(key, meta_value, configuration)
@@ -185,12 +167,12 @@ module OpenHAB
               #
               # @return [Boolean] True if the given namespace exists, false otherwise
               #
-              def has_key?(namespace)
+              def key?(namespace)
                 !NamespaceAccessor.registry.get(MetadataKey.new(namespace, @item_name)).nil?
               end
 
-              alias key? has_key?
-              alias include? has_key?
+              alias has_key? key?
+              alias include? key?
 
               #
               # Merge the given hash with the current metadata. Existing namespace that matches the name
@@ -201,25 +183,9 @@ module OpenHAB
 
                 others.each do |other|
                   case other
-                  when Hash
-                    other.each do |key, new_meta|
-                      if block_given?
-                        current_meta = self[key]&.to_a
-                        new_meta = yield key, current_meta, new_meta unless current_meta.nil?
-                      end
-                      self[key] = new_meta
-                    end
-                  when self.class
-                    other.each do |key, new_value, new_config|
-                      new_meta = new_value, new_config
-                      if block_given?
-                        current_meta = self[key]&.to_a
-                        new_meta = yield key, current_meta, new_meta unless current_meta.nil?
-                      end
-                      self[key] = new_meta
-                    end
-                  else
-                    raise ArgumentError, "merge only supports Hash, or another item's metadata"
+                  when Hash then merge_hash!(other)
+                  when self.class then merge_metadata!(other)
+                  else raise ArgumentError, "merge only supports Hash, or another item's metadata"
                   end
                 end
                 self
@@ -238,7 +204,65 @@ module OpenHAB
               # @return [Java::org::openhab::core::items::MetadataRegistry]
               #
               def self.registry
-                @@registry ||= OpenHAB::OSGI.service('org.openhab.core.items.MetadataRegistry')
+                @registry ||= OpenHAB::OSGI.service('org.openhab.core.items.MetadataRegistry')
+              end
+
+              private
+
+              #
+              # perform an updated based on the supplied value
+              #
+              # @param [MetadataItem,Metadata,Array,Hash] value to perform update from
+              #
+              # @return [Array<Object,Hash>] Array containing the value and configuration based on the
+              #   the supplied object
+              #
+              def update_from_value(value)
+                case value
+                when MetadataItem then [value.value, value.__getobj__]
+                when Metadata then [value.value, value.configuration]
+                when Array
+                  raise ArgumentError, 'Array must contain 2 elements: value, config' if value.length != 2
+
+                  value
+                when Hash then [nil, value]
+                else [value, nil]
+                end
+              end
+
+              #
+              # Merge the metadata from the supplied other metadata object
+              #
+              # @param [Hash] other metadata object to merge
+              # @yield [key, current_metadata, new_meta] to process merge
+              #
+              #
+              def merge_metadata!(other)
+                other.each do |key, new_value, new_config|
+                  new_meta = new_value, new_config
+                  if block_given?
+                    current_meta = self[key]&.to_a
+                    new_meta = yield key, current_meta, new_meta unless current_meta.nil?
+                  end
+                  self[key] = new_meta
+                end
+              end
+
+              #
+              # Merge a hash into the metadata
+              #
+              # @param [Hash] other to merge into metadata
+              # @yield [key, current_metadata, new_meta] to process merge
+              #
+              #
+              def merge_hash!(other)
+                other.each do |key, new_meta|
+                  if block_given?
+                    current_meta = self[key]&.to_a
+                    new_meta = yield key, current_meta, new_meta unless current_meta.nil?
+                  end
+                  self[key] = new_meta
+                end
               end
             end
 

data/lib/openhab/core/dsl/monkey_patch/items/persistence.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module Core
+    module DSL
+      module MonkeyPatch
+        module Items
+          #
+          # Persistence extension for Items
+          #
+          module Persistence
+            %w[persist last_update].each do |method|
+              define_method(method) do |service = nil|
+                service ||= persistence_service
+                PersistenceExtensions.public_send(method, self, service&.to_s)
+              end
+            end
+
+            #
+            # Return the previous state of the item
+            #
+            # @param skip_equal [Boolean] if true, skips equal state values and
+            #        searches the first state not equal the current state
+            # @param service [String] the name of the PersistenceService to use
+            #
+            # @return the previous state or nil if no previous state could be found,
+            #         or if the default persistence service is not configured or
+            #         does not refer to a valid service
+            #
+            def previous_state(service = nil, skip_equal: false)
+              service ||= persistence_service
+              PersistenceExtensions.previous_state(self, skip_equal, service&.to_s)
+            end
+
+            %w[
+              average_since
+              changed_since
+              delta_since
+              deviation_since
+              evolution_rate
+              historic_state
+              maximum_since
+              minimum_since
+              sum_since
+              updated_since
+              variance_since
+            ].each do |method|
+              define_method(method) do |timestamp, service = nil|
+                service ||= persistence_service
+                if timestamp.is_a? Java::JavaTimeTemporal::TemporalAmount
+                  timestamp = Java::JavaTime::ZonedDateTime.now.minus(timestamp)
+                end
+                PersistenceExtensions.public_send(method, self, timestamp, service&.to_s)
+              end
+            end
+
+            private
+
+            #
+            # Get the specified persistence service from the current thread local variable
+            #
+            # @return [Object] Persistence service name as String or Symbol, or nil if not set
+            #
+            def persistence_service
+              Thread.current.thread_variable_get(:persistence_service)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/openhab/core/dsl/monkey_patch/items/switch_item.rb

@@ -74,7 +74,8 @@ class Java::OrgOpenhabCoreLibraryItems::SwitchItem
   #
   # @param [Object] other object to compare to
   #
-  # @return [Boolean] True if other is a OnOffType and other equals state for this switch item, otherwise result from super
+  # @return [Boolean] True if other is a OnOffType and other equals state for this switch item,
+  #   otherwise result from super
   #
   def ==(other)
     if other.is_a? OnOffType

data/lib/openhab/core/dsl/monkey_patch/ruby/range.rb

@@ -24,7 +24,8 @@ module OpenHAB
             #
             # @param [Object] other object to compare for case equals
             #
-            # @return [Boolean] if other is DimmerItem and state is covered by range, result from parent Range class if not DimmerItem
+            # @return [Boolean] if other is DimmerItem and state is covered by range,
+            #   result from parent Range class if not DimmerItem
             #
             def ===(other)
               return super unless other.is_a? DimmerItem

data/lib/openhab/core/dsl/monkey_patch/ruby/ruby.rb

@@ -3,3 +3,5 @@
 # Monkey patch ruby
 require 'openhab/core/dsl/monkey_patch/ruby/range'
 require 'openhab/core/dsl/monkey_patch/ruby/number'
+require 'openhab/core/dsl/monkey_patch/ruby/string'
+require 'bigdecimal/util'

data/lib/openhab/core/dsl/monkey_patch/ruby/string.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'openhab/core/dsl/types/quantity'
+
+module OpenHAB
+  module Core
+    module DSL
+      module MonkeyPatch
+        module Ruby
+          #
+          # Extend String class
+          #
+          module StringExtensions
+            include OpenHAB::Core
+
+            #
+            # Compares String to another object
+            #
+            # @param [Object] other object to compare to
+            #
+            # @return [Boolean]  true if the two objects contain the same value, false otherwise
+            #
+            def ==(other)
+              case other
+              when OpenHAB::Core::DSL::Types::Quantity, QuantityType
+                other == self
+              else
+                super
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+#
+# Prepend String class with comparison extensions
+#
+class String
+  prepend OpenHAB::Core::DSL::MonkeyPatch::Ruby::StringExtensions
+end

data/lib/openhab/core/dsl/monkey_patch/types/decimal_type.rb

@@ -10,15 +10,51 @@ class Java::OrgOpenhabCoreLibraryTypes::DecimalType
   # rubocop:enable Style/ClassAndModuleChildren
 
   #
-  # Compare self to other using Java BigDecimal compare method
+  # Compare DecimalType to supplied object
   #
   # @param [Object] other object to compare to
   #
-  # @return [Boolean] True if have the same BigDecimal representation, false otherwise
+  # @return [Integer] -1,0,1 or nil depending on value supplied, nil comparison to supplied object is not possible.
   #
-  def ==(other)
-    return equals(other) unless other.is_a? Integer
+  def <=>(other)
+    logger.trace("#{self.class} #{self} <=> #{other} (#{other.class})")
+    case other
+    when Numeric
+      to_big_decimal.compare_to(other.to_d)
+    when Java::OrgOpenhabCoreTypes::UnDefType
+      1
+    else
+      other = other.state if other.respond_to? :state
+      compare_to(other)
+    end
+  end
+
+  #
+  # Coerce objects into a DecimalType
+  #
+  # @param [Object] other object to coerce to a DecimalType if possible
+  #
+  # @return [Object] Numeric when applicable
+  #
+  def coerce(other)
+    logger.trace("Coercing #{self} as a request from #{other.class}")
+    case other
+    when Numeric
+      [other.to_d, to_big_decimal]
+    else
+      [other, self]
+    end
+  end
 
-    to_big_decimal.compare_to(Java::JavaMath::BigDecimal.new(other)).zero?
+  #
+  # Compare self to other through the spaceship operator
+  #
+  # @param [Object] other object to compare to
+  #
+  # @return [Boolean] True if equals
+  #
+  def ==(other)
+    logger.trace("#{self.class} #{self} == #{other} (#{other.class})")
+    (self <=> other).zero?
   end
 end