openhab-scripting 2.16.2 → 2.16.3

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  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

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module DSL
+    module MonkeyPatch
+      #
+      # Patches OpenHAB items
+      #
+      module Items
+        java_import Java::OrgOpenhabCoreLibraryItems::SwitchItem
+
+        # Alias class names for easy is_a? comparisons
+        ::Switch = SwitchItem
+
+        #
+        # Monkeypatching SwitchItem to add Ruby Support methods
+        #
+        class SwitchItem
+          java_import Java::OrgOpenhabCoreLibraryTypes::OnOffType
+          #
+          # Send the OFF command to the switch
+          #
+          #
+          def off
+            command(OnOffType::OFF)
+          end
+
+          #
+          # Send the OFF command to the switch
+          #
+          #
+          def on
+            command(OnOffType::ON)
+          end
+
+          #
+          # Check if a switch is on
+          #
+          # @return [Boolean] True if the switch is on, false otherwise
+          #
+          def on?
+            state? && state == OnOffType::ON
+          end
+
+          alias truthy? on?
+
+          #
+          # Check if a switch is off
+          #
+          # @return [Boolean] True if the switch is off, false otherwise
+          #
+          def off?
+            state? && state == OnOffType::OFF
+          end
+
+          #
+          # Send a command to invert the state of the switch
+          #
+          # @return [OnOffType] Inverted state
+          #
+          def toggle
+            self << !self
+          end
+
+          #
+          # Return the inverted state of the switch: ON if the switch is OFF, UNDEF or NULL; OFF if the switch is ON
+          #
+          # @return [OnOffType] Inverted state
+          #
+          def !
+            return !state if state?
+
+            OnOffType::ON
+          end
+
+          #
+          # Check for equality against supplied object
+          #
+          # @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
+          #
+          def ==(other)
+            if other.is_a? OnOffType
+              state? && state == other
+            else
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module DSL
+    module MonkeyPatch
+      module Ruby
+        #
+        # Extend integer to create duration object
+        #
+        module IntegerExtensions
+          include OpenHAB::Core
+
+          #
+          # Create Duration with the specified unit
+          #
+          # @return [Java::JavaTime::Duration] Duration with number of units from self
+          #
+          %w[millis seconds minutes hours].each do |unit|
+            define_method(unit) { Java::JavaTime::Duration.public_send("of_#{unit}", self) }
+          end
+
+          alias second seconds
+          alias millisecond millis
+          alias milliseconds millis
+          alias ms millis
+          alias minute minutes
+          alias hour hours
+        end
+      end
+    end
+  end
+end
+
+#
+# Prepend Integer class with duration extensions
+#
+class Integer
+  prepend OpenHAB::DSL::MonkeyPatch::Ruby::IntegerExtensions
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'java'
+
+# Monkey patch range to support case equality of OpenHab "Numeric" Objects
+
+module OpenHAB
+  module DSL
+    #
+    # MonkeyPatch both Ruby and OpenHAB Objects to support DSL
+    #
+    module MonkeyPatch
+      #
+      # MonkeyPatch ruby object to support DSL
+      #
+      module Ruby
+        #
+        # Extensions for Range Class to support DimmerItems
+        #
+        module RangeExtensions
+          java_import Java::OrgOpenhabCoreLibraryItems::DimmerItem
+
+          #
+          # Override range === method to support DimmerItems
+          #
+          # @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
+          #
+          def ===(other)
+            return super unless other.is_a? DimmerItem
+
+            cover? other.state.to_i
+          end
+        end
+      end
+    end
+  end
+end
+
+#
+# Prepend Range class with RangeExtensions
+#
+class Range
+  prepend OpenHAB::DSL::MonkeyPatch::Ruby::RangeExtensions
+end

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

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Monkey patch ruby
+require 'openhab/dsl/monkey_patch/ruby/range'
+require 'openhab/dsl/monkey_patch/ruby/number'
+require 'openhab/dsl/monkey_patch/ruby/string'
+require 'bigdecimal/util'

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'openhab/dsl/types/quantity'
+
+module OpenHAB
+  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::DSL::Types::Quantity, QuantityType
+              other == self
+            else
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+#
+# Prepend String class with comparison extensions
+#
+class String
+  prepend OpenHAB::DSL::MonkeyPatch::Ruby::StringExtensions
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'java'
+
+module OpenHAB
+  module DSL
+    module MonkeyPatch
+      #
+      # Patches OpenHAB types
+      #
+      module Types
+        java_import Java::OrgOpenhabCoreLibraryTypes::DecimalType
+
+        #
+        # MonkeyPatching Decimal Type
+        #
+        class DecimalType
+          #
+          # @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.
+          #
+          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
+
+          #
+          # Compare self to other through the spaceship operator
+          # Compare self to other using Java BigDecimal compare method
+          #
+          # @param [Object] other object to compare to
+          #
+          # @return [Boolean] True if have the same BigDecimal representation, false otherwise
+          #
+          def ==(other)
+            logger.trace("#{self.class} #{self} == #{other} (#{other.class})")
+            (self <=> other).zero?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/openhab/dsl/monkey_patch/types/on_off_type.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'java'
+
+module OpenHAB
+  module DSL
+    module MonkeyPatch
+      #
+      # Patches OpenHAB types
+      #
+      module Types
+        java_import Java::OrgOpenhabCoreLibraryTypes::OnOffType
+
+        #
+        # Monkey patching OnOffType
+        #
+        class OnOffType
+          #
+          # Invert the type
+          #
+          # @return [Java::OrgOpenhabCoreLibraryTypes::OnOffType] OFF if ON, ON if OFF
+          #
+          def !
+            return OFF if self == ON
+            return ON if self == OFF
+          end
+
+          # Check if the supplied object is case equals to self
+          #
+          # @param [Object] other object to compare
+          #
+          # @return [Boolean] True if the other object responds to on?/off? and is in the same state as this object,
+          #  nil if object cannot be compared
+          #
+          def ===(other)
+            # A case statement here causes and infinite loop
+            # rubocop:disable Style/CaseLikeIf
+            if self == ON
+              other.on? if other.respond_to? :on?
+            elsif self == OFF
+              other.off? if other.respond_to?('off?')
+            else
+              false
+            end
+            # rubocop:enable Style/CaseLikeIf
+          end
+        end
+      end
+    end
+  end
+end

data/lib/openhab/dsl/monkey_patch/types/open_closed_type.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'java'
+
+module OpenHAB
+  module DSL
+    module MonkeyPatch
+      #
+      # Patches OpenHAB types
+      #
+      module Types
+        java_import Java::OrgOpenhabCoreLibraryTypes::OpenClosedType
+
+        #
+        # Monkey patch for DSL use
+        #
+        class OpenClosedType
+          java_import Java::OrgOpenhabCoreLibraryItems::ContactItem
+
+          #
+          # Check if the supplied object is case equals to self
+          #
+          # @param [Object] other object to compare
+          #
+          # @return [Boolean] True if the other object is a ContactItem and has the same state
+          #
+          def ===(other)
+            super unless other.is_a? ContactItem
+
+            self == other.state
+          end
+        end
+      end
+    end
+  end
+end