openhab-scripting 2.16.0 → 2.17.0

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

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+require 'forwardable'
+require 'java'
+
+module OpenHAB
+  module DSL
+    module Items
+      #
+      # Delegator to OpenHAB String Item
+      #
+      class StringItem
+        extend Forwardable
+        include Comparable
+
+        # @return [Regex] Regular expression matching blank strings
+        BLANK_RE = /\A[[:space:]]*\z/.freeze
+        private_constant :BLANK_RE
+
+        def_delegator :@string_item, :to_s
+
+        #
+        # Create a new StringItem
+        #
+        # @param [Java::Org::openhab::core::library::items::StringItem] string_item OpenHAB string item to delegate to
+        #
+        def initialize(string_item)
+          @string_item = string_item
+          super()
+        end
+
+        #
+        # Convert the StringItem into a String
+        #
+        # @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
+        end
+
+        #
+        # Detect if the string is blank (not set or only whitespace)
+        #
+        # @return [Boolean] True if string item is not set or contains only whitespace, false otherwise
+        #
+        def blank?
+          return true unless @string_item.state?
+
+          @string_item.state.to_full_string.to_s.empty? || BLANK_RE.match?(self)
+        end
+
+        #
+        # Check if StringItem is truthy? as per defined by library
+        #
+        # @return [Boolean] True if item is not in state UNDEF or NULL and value is not blank
+        #
+        def truthy?
+          @string_item.state? && blank? == false
+        end
+
+        #
+        # Compare StringItem to supplied object
+        #
+        # @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)
+          case other
+          when StringItem
+            @string_item.state <=> other.state
+          when String
+            @string_item.state.to_s <=> other
+          else
+            @string_item.state <=> other
+          end
+        end
+
+        #
+        # Forward missing methods to Openhab String Item or String representation of the item if they are defined
+        #
+        # @param [String] meth method name
+        # @param [Array] args arguments for method
+        # @param [Proc] block <description>
+        #
+        # @return [Object] Value from delegated method in OpenHAB StringItem or Ruby String
+        #
+        def method_missing(meth, *args, &block)
+          if @string_item.respond_to?(meth)
+            @string_item.__send__(meth, *args, &block)
+          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)
+          else
+            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
+end

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

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# Monkey patch actions
+require 'openhab/dsl/monkey_patch/actions/script_thing_actions'

data/lib/openhab/dsl/monkey_patch/actions/script_thing_actions.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'java'
+
+module OpenHAB
+  module DSL
+    module MonkeyPatch
+      #
+      # Patches OpenHAB actions
+      #
+      module Actions
+        java_import Java::OrgOpenhabCoreAutomationModuleScriptInternalDefaultscope::ScriptThingActions
+
+        #
+        # MonkeyPatching ScriptThingActions
+        #
+        class ScriptThingActions
+          field_reader :THING_ACTIONS_MAP
+
+          #
+          # Fetch keys for all actions defined in OpenHAB
+          #
+          # @return [Set] of keys for defined actions in the form of 'scope-thing_uid'
+          #
+          def action_keys
+            ScriptThingActions.THING_ACTIONS_MAP.keys
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'openhab/dsl/monkey_patch/events/item_state_changed'
+require 'openhab/dsl/monkey_patch/events/thing_status_info'
+require 'openhab/dsl/monkey_patch/events/item_command'

data/lib/openhab/dsl/monkey_patch/events/item_command.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'java'
+
+module OpenHAB
+  module DSL
+    module MonkeyPatch
+      #
+      # Patches OpenHAB events
+      #
+      module Events
+        java_import Java::OrgOpenhabCoreItemsEvents::ItemCommandEvent
+
+        #
+        # Monkey patch with ruby style accesors
+        #
+        class ItemCommandEvent
+          alias command item_command
+        end
+      end
+    end
+  end
+end

data/lib/openhab/dsl/monkey_patch/events/item_state_changed.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'java'
+
+module OpenHAB
+  module DSL
+    module MonkeyPatch
+      #
+      # Patches OpenHAB events
+      #
+      module Events
+        java_import Java::OrgOpenhabCoreItemsEvents::ItemStateChangedEvent
+
+        #
+        # MonkeyPatch with ruby style accessors
+        #
+        class ItemStateChangedEvent
+          #
+          # Get the item that caused the state change
+          #
+          # @return [Item] Item that caused state change
+          #
+          def item
+            # rubocop:disable Style/GlobalVars
+            $ir.get(item_name)
+            # rubocop:enable Style/GlobalVars
+          end
+
+          alias state item_state
+          alias last old_item_state
+        end
+      end
+    end
+  end
+end

data/lib/openhab/dsl/monkey_patch/events/thing_status_info.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'java'
+
+module OpenHAB
+  module DSL
+    module MonkeyPatch
+      #
+      # Patches OpenHAB events
+      #
+      module Event
+        java_import Java::OrgOpenhabCoreThingEvents::ThingStatusInfoChangedEvent
+        java_import Java::OrgOpenhabCoreThingEvents::ThingStatusInfoEvent
+        #
+        # Monkey patch with ruby style accessors
+        #
+        class ThingStatusInfoChangedEvent
+          alias uid get_thing_uid
+          alias last get_old_status_info
+          alias status status_info
+        end
+
+        #
+        # Monkey patch with ruby style accessors
+        #
+        class ThingStatusInfoEvent
+          alias uid get_thing_uid
+          alias status status_info
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'java'
+
+module OpenHAB
+  module DSL
+    module MonkeyPatch
+      #
+      # Patches OpenHAB items
+      #
+      module Items
+        java_import Java::OrgOpenhabCoreLibraryItems::ContactItem
+
+        #
+        # Alias class for ContactItem
+        #
+        ::Contact = ContactItem
+
+        #
+        # Monkey patch Contact Item with Ruby methods
+        #
+        class ContactItem
+          java_import org.openhab.core.library.types.OpenClosedType
+          #
+          # Check if the contact is open
+          #
+          # @return [Boolean] True if contact has state and is open, false otherwise
+          #
+          def open?
+            state? && state == OpenClosedType::OPEN
+          end
+
+          #
+          # Check if the contact is closed
+          #
+          # @return [Boolean] True if contact has state and is closed, false otherwise
+          #
+          def closed?
+            state? && state == OpenClosedType::CLOSED
+          end
+
+          #
+          # Compares contacts to OpenClosedTypes
+          #
+          # @param [Object] other object to compare to
+          #
+          # @return [Boolean] True if contact has a state and state equals other, nil if no state,
+          #   result from super if not supplied an OpenClosedType
+          #
+          def ==(other)
+            if other.is_a? OpenClosedType
+              state? && state == other
+            else
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require 'java'
+
+module OpenHAB
+  module DSL
+    module MonkeyPatch
+      #
+      # Patches OpenHAB items
+      #
+      module Items
+        java_import Java::OrgOpenhabCoreLibraryItems::DimmerItem
+        java_import Java::OrgOpenhabCoreItems::GenericItem
+
+        #
+        # Alias class for is_a? testing
+        #
+        ::Dimmer = DimmerItem
+
+        #
+        # Monkey Patch DimmerItem
+        #
+        class DimmerItem
+          include Comparable
+          java_import Java::OrgOpenhabCoreLibraryTypes::DecimalType
+          java_import Java::OrgOpenhabCoreLibraryTypes::IncreaseDecreaseType
+
+          #
+          # Add the current dimmer value to the supplied object
+          #
+          # @param [Object] other object to add the dimmer value to
+          #
+          # @return [Integer] Current dimmer value plus value of supplied object
+          #
+          def +(other)
+            return unless state?
+
+            state.to_big_decimal.intValue + other
+          end
+
+          #
+          # Subtract the supplied object from the current value of the dimmer
+          #
+          # @param [Object] other object to subtract from the dimmer value
+          #
+          # @return [Integer] Current dimmer value minus value of supplied object
+          #
+          def -(other)
+            return unless state?
+
+            state.to_big_decimal.intValue - other
+          end
+
+          #
+          # Dim the dimmer
+          #
+          # @param [Integer] amount to dim by
+          #
+          # @return [Integer] level target for dimmer
+          #
+          def dim(amount = 1)
+            return unless state?
+
+            target = [state.to_big_decimal.intValue - amount, 0].max
+
+            if amount == 1
+              command(IncreaseDecreaseType::DECREASE)
+            else
+              command(target)
+            end
+
+            target
+          end
+
+          #
+          # Brighten the dimmer
+          #
+          # @param [Integer] amount to brighten by
+          #
+          # @return [Integer] level target for dimmer
+          #
+          def brighten(amount = 1)
+            return unless state?
+
+            target = state.to_big_decimal.intValue + amount
+
+            if amount == 1
+              command(IncreaseDecreaseType::INCREASE)
+            else
+              command(target)
+            end
+            target
+          end
+
+          #
+          # Compare DimmerItem to supplied object
+          #
+          # @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("Comparing #{self} to #{other}")
+            case other
+            when 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
+              [other, state]
+            end
+          end
+
+          #
+          # Compare DimmerItem to supplied object.
+          # The == operator needs to be overridden because the parent java object
+          # has .equals which overrides the <=> operator above
+          #
+          # @param [Object] other object to compare to
+          #
+          # @return [Integer] true if the two objects contain the same value, false otherwise
+          #
+          def ==(other)
+            (self <=> other).zero?
+          end
+
+          #
+          # Check if dimmer has a state and state is not zero
+          #
+          # @return [Boolean] True if dimmer is not NULL or UNDEF and value is not 0
+          #
+          def truthy?
+            state? && state != DecimalType::ZERO
+          end
+
+          #
+          # Value of dimmer
+          #
+          # @return [Integer] Value of dimmer or nil if state is UNDEF or NULL
+          #
+          def to_i
+            state&.to_big_decimal&.intValue
+          end
+
+          alias to_int to_i
+
+          #
+          # Return the string representation of the dimmer item
+          #
+          # @return [String] String version of the dimmer value
+          #
+          def to_s
+            to_i.to_s
+          end
+
+          #
+          # Check if dimmer is on
+          #
+          # @return [Boolean] True if item is not UNDEF or NULL and has a value greater than 0
+          #
+          def on?
+            state&.to_big_decimal&.intValue&.positive?
+          end
+
+          #
+          # Check if dimmer is off
+          #
+          # @return [Boolean] True if item is not UNDEF or NULL and has a state of 0
+          #
+          def off?
+            state&.to_big_decimal&.intValue&.zero?
+          end
+        end
+      end
+    end
+  end
+end