openhab-scripting 2.16.2 → 2.19.0

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

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'java'
+
+module OpenHAB
+  module DSL
+    module Items
+      #
+      # Delegator to OpenHAB Rollershutter Item
+      #
+      class RollershutterItem < Numeric
+        extend Forwardable
+        include Comparable
+
+        def_delegator :@rollershutter_item, :to_s
+
+        java_import Java::OrgOpenhabCoreLibraryTypes::PercentType
+        java_import Java::OrgOpenhabCoreLibraryTypes::UpDownType
+        java_import Java::OrgOpenhabCoreLibraryTypes::StopMoveType
+
+        #
+        # Creates a new RollershutterItem
+        #
+        # @param [Java::OrgOpenhabCoreLibraryItems::RollershutterItem] rollershutter_item
+        #   The OpenHAB RollershutterItem to delegate to
+        #
+        def initialize(rollershutter_item)
+          logger.trace("Wrapping #{rollershutter_item}")
+          @rollershutter_item = rollershutter_item
+
+          super()
+        end
+
+        #
+        # Check if the rollershutter is up
+        #
+        # @return [Boolean] true if the rollershutter is up, false otherwise
+        #
+        def up?
+          state.as(UpDownType) == UpDownType::UP
+        end
+
+        #
+        # Check if the rollershutter is down
+        #
+        # @return [Boolean] true if the rollershutter is down, false otherwise
+        #
+        def down?
+          state.as(UpDownType) == UpDownType::DOWN
+        end
+
+        #
+        # Returns the rollershutter's position
+        #
+        # @return [Java::OrgOpenhabCoreLibraryTypes::PercentType] the position of the rollershutter
+        #
+        def position
+          state.as(PercentType)
+        end
+
+        #
+        # Compare the rollershutter's position against another object
+        #
+        # @param [Object] other object to compare against
+        #
+        # @return [Integer] -1, 0 or 1 depending on the result of the comparison
+        #
+        def <=>(other)
+          case other
+          when PercentType, Java::OrgOpenhabCoreLibraryTypes::DecimalType then position.compare_to(other)
+          when Numeric then position.int_value <=> other
+          when RollershutterItem then position.compare_to(other.position)
+          when UpDownType then state.as(UpDownType) == other
+          end
+        end
+
+        #
+        # Coerce self into other to enable calculations
+        #
+        # @param [Numeric] other Other numeric to coerce into
+        #
+        # @return [Array<Numeric>] an array of other and self coerced into other's type
+        #
+        def coerce(other)
+          raise ArgumentError, "Cannot coerce to #{other.class}" unless other.is_a? Numeric
+
+          case other
+          when Integer then [other, position.int_value]
+          when Float then [other, position.float_value]
+          end
+        end
+
+        #
+        # Case equality
+        #
+        # @param [Java::OrgOpenhabCoreLibraryTypes::UpDownType, Numeric] other Other object to compare against
+        #
+        # @return [Boolean] true if self can be defined as other, false otherwise
+        #
+        def ===(other)
+          super unless other.is_a? UpDownType
+
+          state.as(UpDownType).equals(other)
+        end
+
+        #
+        # Sends an UP command to the Item
+        #
+        def up
+          command UpDownType::UP
+        end
+
+        #
+        # Sends a DOWN command to the Item
+        #
+        def down
+          command UpDownType::DOWN
+        end
+
+        #
+        # Sends a STOP command to the Item
+        #
+        def stop
+          command StopMoveType::STOP
+        end
+
+        #
+        # Sends a MOVE command to the Item
+        #
+        def move
+          command StopMoveType::MOVE
+        end
+
+        #
+        # Define math operations
+        #
+        %i[+ - * / %].each do |operator|
+          define_method(operator) do |other|
+            right, left = coerce(other)
+            left.send(operator, right)
+          end
+        end
+
+        #
+        # Checks if this method responds to the missing method
+        #
+        # @param [String] meth 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?(meth, _include_private = false)
+          @rollershutter_item.respond_to?(meth) || position.respond_to?(meth)
+        end
+
+        #
+        # Forward missing methods to Openhab RollershutterItem or the PercentType representing it's state
+        #   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 NumberItem
+        #
+        def method_missing(meth, *args, &block)
+          if @rollershutter_item.respond_to?(meth)
+            @rollershutter_item.__send__(meth, *args, &block)
+          elsif position.respond_to?(meth)
+            position.__send__(meth, *args, &block)
+          else
+            raise NoMethodError, "No method `#{meth}' defined for #{self.class}"
+          end
+        end
+      end
+    end
+  end
+end

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