openhab-scripting 2.16.1 → 2.18.0

data/lib/openhab/core/dsl.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require 'java'
-require 'core/log'
-require 'core/dsl/monkey_patch/events'
-require 'core/dsl/monkey_patch/ruby/ruby'
-require 'core/dsl/monkey_patch/items/items'
-require 'core/dsl/monkey_patch/types/types'
-require 'core/dsl/monkey_patch/actions/actions'
-require 'core/dsl/rule/rule'
-require 'core/dsl/actions'
-require 'core/dsl/timers'
-require 'core/dsl/group'
-require 'core/dsl/things'
-require 'core/dsl/items/items'
-require 'core/dsl/items/number_item'
-require 'core/dsl/time_of_day'
-require 'core/dsl/gems'
-require 'core/dsl/units'
-require 'core/dsl/types/quantity'
-require 'core/dsl/states'
-require 'core/dsl/persistence'
-
-module OpenHAB
-  #
-  #  Holds core functions for OpenHAB Helper Library
-  #
-  module Core
-    #
-    # Module to be extended to access the OpenHAB Ruby DSL
-    #
-    module DSL
-      # Extend the calling module/class with the DSL
-      # rubocop: disable Metrics/MethodLength
-      def self.extended(base)
-        base.send :include, OpenHAB::Core::DSL::Rule
-        base.send :include, OpenHAB::Core::DSL::Items
-        base.send :include, OpenHAB::Core::DSL::Types
-        base.send :include, OpenHAB::Core::DSL::Groups
-        base.send :include, OpenHAB::Core::DSL::Units
-        base.send :include, OpenHAB::Core::DSL::Actions
-        base.send :include, OpenHAB::Core::DSL::Timers
-        base.send :include, OpenHAB::Core::DSL::States
-        base.send :include, OpenHAB::Core::DSL::Tod
-        base.send :include, OpenHAB::Core::DSL::Persistence
-        base.send :include, Things
-      end
-      # rubocop: enable Metrics/MethodLength
-    end
-  end
-end

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

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-require 'java'
-require 'openhab/osgi'
-
-module OpenHAB
-  module Core
-    module DSL
-      #
-      # Module to import and steramlime access to OpenHAB actions
-      #
-      module Actions
-        java_import org.openhab.core.library.types.PercentType
-        include Logging
-
-        OpenHAB::OSGI.services('org.openhab.core.model.script.engine.action.ActionService')&.each do |service|
-          java_import service.actionClass.to_s
-          logger.trace("Loaded ACTION: #{service.actionClass}")
-        end
-        # Import common actions
-        %w[Exec HTTP Ping].each { |action| java_import "org.openhab.core.model.script.actions.#{action}" }
-
-        #
-        # Return an OpenHAB Action object for the given scope and thing
-        #
-        # @param scope [String] The action scope
-        # @param thing_uid [String] Thing UID
-        #
-        # @return [Object] OpenHAB action
-        #
-        def actions(scope, thing_uid)
-          # rubocop: disable Style/GlobalVars
-          $actions.get(scope, thing_uid)
-          # rubocop: enable Style/GlobalVars
-        end
-
-        #
-        # Gets the list of action objects associated with a specific ThingUID
-        #
-        # @param [Java::org::openhab::core::thing::ThingUID] thing_uid to get associated actions for
-        #
-        # @return [Array] of action objects associated with thing_uid, may be empty
-        #
-        def actions_for_thing(thing_uid)
-          thing_uid = thing_uid.to_s
-          # rubocop: disable Style/GlobalVars
-          action_keys = $actions.action_keys
-          # rubocop: enable Style/GlobalVars
-          logger.trace("Registered actions: '#{action_keys}' for thing '#{thing_uid}'")
-          action_keys.map { |action_key| action_key.split('-', 2) }
-                     .select { |action_pair| action_pair.last == thing_uid }
-                     .map(&:first)
-                     .map { |scope| actions(scope, thing_uid) }
-        end
-
-        #
-        # Send notification to an email or broadcast
-        #
-        # @param msg [String] The notification message to send
-        # @param email [String] The email address to send to. If nil, the message will be broadcasted
-        #
-        # @return [void]
-        #
-        def notify(msg, email: nil)
-          unless defined? NotificationAction
-            raise NoMethodError, 'NotificationAction is not available. Please install the OpenHAB cloud addon'
-          end
-
-          if email
-            NotificationAction.sendNotification email, msg
-          else
-            NotificationAction.sendBroadcastNotification msg
-          end
-        end
-
-        #
-        # Say text via OpenHAB Text-To-Speech service, Voice.say()
-        #
-        # @param text [String] The text to say
-        # @param voice [String] Specify a particular voice to use
-        # @param sink [String] Specify a particular sink to output the speech
-        # @param volume [PercentType] Specify the volume for the speech
-        #
-        # @return [void]
-        #
-        def say(text, voice: nil, sink: nil, volume: nil)
-          volume = PercentType.new(volume&.to_i) unless volume.is_a?(PercentType) || volume.nil?
-          Voice.say text, voice, sink, volume
-        end
-
-        #
-        # Play an audio file via OpenHAB sound service, Audio.playSound()
-        #
-        # @param filename [String] The sound file to play
-        # @param sink [String] Specify a particular sink to output the speech
-        # @param volume [PercentType] Specify the volume for the speech
-        #
-        # @return [void]
-        #
-        def play_sound(filename, sink: nil, volume: nil)
-          volume = PercentType.new(volume&.to_i) unless volume.is_a?(PercentType) || volume.nil?
-          Audio.playSound sink, filename, volume
-        end
-      end
-    end
-  end
-end

data/lib/openhab/core/dsl/entities.rb

@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-
-require 'pp'
-require 'java'
-require 'set'
-require 'core/dsl/group'
-require 'core/log'
-require 'core/dsl/items/number_item'
-require 'core/dsl/items/string_item'
-
-# Automation lookup and injection of OpenHab entities
-java_import org.openhab.core.items.GroupItem
-
-#
-# Implements const_missing to return OpenHAB items or things if mapping to missing name if they exist
-#
-# @param [String] name Capital string that was not set as a constant and to be looked up
-#
-# @return [Object] OpenHAB Item or Thing if their name exist in OpenHAB item and thing regestries
-#
-def Object.const_missing(name)
-  EntityLookup.lookup_item(name) || EntityLookup.lookup_thing(name) || super
-end
-
-#
-# Manages access to OpenHAB entities
-#
-module EntityLookup
-  include Logging
-  #
-  # Decorate items with Ruby wrappers
-  #
-  # @param [Array] items Array of items to decorate
-  #
-  # @return [Array] Array of decorated items
-  #
-  # rubocop: disable Metrics/MethodLength
-  # Disabled line length - case dispatch pattern
-  def self.decorate_items(*items)
-    items.flatten.map do |item|
-      case item
-      when GroupItem
-        decorate_group(item)
-      when Java::Org.openhab.core.library.items::NumberItem
-        OpenHAB::Core::DSL::Items::NumberItem.new(item)
-      when Java::Org.openhab.core.library.items::StringItem
-        OpenHAB::Core::DSL::Items::StringItem.new(item)
-      else
-        item
-      end
-    end
-  end
-  # rubocop: enable Metrics/MethodLength
-
-  #
-  # Loops up a Thing in the OpenHAB registry replacing '_' with ':'
-  #
-  # @param [String] name of Thing to lookup in Thing registry
-  #
-  # @return [Thing] if found, nil otherwise
-  #
-  def self.lookup_thing(name)
-    logger.trace("Looking up thing(#{name})")
-    # Convert from : syntax to underscore
-    name = name.to_s if name.is_a? Symbol
-
-    # Thing UIDs have at least 3 segements
-    return if name.count('_') < 3
-
-    name = name.gsub('_', ':')
-    # rubocop: disable Style/GlobalVars
-    $things.get(Java::OrgOpenhabCoreThing::ThingUID.new(name))
-    # rubocop: enable Style/GlobalVars
-  end
-
-  #
-  # Lookup OpenHAB items in item registry
-  #
-  # @param [String] name of item to lookup
-  #
-  # @return [Item] OpenHAB item if registry contains a matching item, nil othewise
-  #
-  def self.lookup_item(name)
-    logger.trace("Looking up item(#{name})")
-    name = name.to_s if name.is_a? Symbol
-    # rubocop: disable Style/GlobalVars
-    item = $ir.get(name)
-    # rubocop: enable Style/GlobalVars
-    EntityLookup.decorate_items(item).first
-  end
-
-  #
-  # Automatically looks up OpenHAB items and things in appropriate registries
-  #
-  # @param [method] method Name of item to lookup
-  # @param [<Type>] args method arguments
-  # @param [<Type>] block supplied to missing method
-  #
-  # @return [Object] Item or Thing if found in registry
-  #
-  def method_missing(method, *args, &block)
-    return if method.to_s == 'scriptLoaded'
-    return if method.to_s == 'scriptUnloaded'
-
-    logger.trace("method missing, performing OpenHab Lookup for: #{method}")
-    EntityLookup.lookup_item(method) || EntityLookup.lookup_thing(method) || super
-  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)
-    logger.trace("Checking if OpenHAB entites exist for #{method_name}")
-    method_name = method_name.to_s if method_name.is_a? Symbol
-
-    method_name == 'scriptLoaded' ||
-      method_name == 'scriptUnloaded' ||
-      EntityLookup.lookup_item(method_name) ||
-      EntityLookup.lookup_thing(method_name) ||
-      super
-  end
-
-  #
-  # Decorate a group from an item base
-  #
-  # @param [OpenHAB item] item item to convert to a group item
-  #
-  # @return [OpenHAB::Core::DSL::Groups::Group] Group created from supplied item
-  #
-  def self.decorate_group(item)
-    group = OpenHAB::Core::DSL::Groups::Group.new(Set.new(EntityLookup.decorate_items(item.all_members.to_a)))
-    group.group = item
-    group
-  end
-end

data/lib/openhab/core/dsl/group.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-require 'delegate'
-require 'forwardable'
-require 'openhab/core/dsl/entities'
-
-module OpenHAB
-  module Core
-    module DSL
-      #
-      # Provides access to OpenHAB Groups
-      #
-      module Groups
-        #
-        # Indicator struct interpreted by rules to trigger based on items contained in a group
-        #
-        GroupItems = Struct.new(:group, keyword_init: true)
-
-        #
-        # Provide access to groups as a set
-        #
-        class Groups < SimpleDelegator
-          #
-          # Get a OpenHAB Group by name
-          # @param [String] name of the group to retrieve
-          #
-          # @return [Set] of OpenHAB Groups
-          #
-          def[](name)
-            group = EntityLookup.lookup_item(name)
-            group.is_a?(Group) ? group : nil
-          end
-        end
-
-        #
-        # Retreive all OpenHAB groups
-        #
-        # @return [Set] of OpenHAB Groups
-        #
-        def groups
-          # rubocop: disable Style/GlobalVars
-          Groups.new(EntityLookup.decorate_items($ir.items.select { |item| item.is_a? GroupItem }))
-          # rubocop: enable Style/GlobalVars
-        end
-
-        # Group class that provides access to OpenHAB group object and delegates other methods to
-        # a set of group items
-        class Group < SimpleDelegator
-          extend Forwardable
-
-          java_import org.openhab.core.items.GroupItem
-
-          # @return [org.openhab.core.items.GroupItem] OpenHAB Java Group Item
-          attr_accessor :group
-
-          # @!macro [attach] def_delegators
-          #   @!method $2
-          #     Forwards to org.openhab.core.items.GroupItem
-          #     @see org::openhab::core::items::GroupItem
-          def_delegator :@group, :name
-          def_delegator :@group, :label
-
-          #
-          # Gets members of this group that are themselves a group
-          #
-          # @return [Set] Set of members that are of type group
-          #
-          def groups
-            group.members.grep(org.openhab.core.items.GroupItem)
-          end
-
-          #
-          # Wraps the group in a struct, this method is intended to be called
-          # as an indicator to the rule method that the user wishes to trigger
-          # based on changes to group items
-          #
-          # @return [GroupItems] Indicator struct used by rules engine to trigger based on item changes
-          #
-          def items
-            GroupItems.new(group: group)
-          end
-
-          #
-          # @return [String] List of groups seperated by commas
-          #
-          def to_s
-            "[#{map(&:to_s).join(',')}]"
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require 'java'
-require 'openhab/core/dsl/entities'
-
-module OpenHAB
-  module Core
-    module DSL
-      #
-      # Manages OpenHAB items
-      #
-      module Items
-        #
-        # Delegates to underlying set of all OpenHAB Items, provides convenience methods
-        #
-        class Items < SimpleDelegator
-          # Fetches the named item from the the ItemRegistry
-          # @param [String] name
-          # @return Item from registry, nil if item missing or requested item is a Group Type
-          def[](name)
-            # rubocop: disable Style/GlobalVars
-            item = $ir.getItem(name)
-            # rubocop: enable Style/GlobalVars
-            item.is_a?(GroupItem) ? nil : item
-          rescue Java::OrgOpenhabCoreItems::ItemNotFoundException
-            nil
-          end
-
-          # Returns true if the given item name exists
-          # @param name [String] Item name to check
-          # @return [Boolean] true if the item exists, false otherwise
-          def include?(name)
-            # rubocop: disable Style/GlobalVars
-            !$ir.getItems(name).empty?
-            # rubocop: enable Style/GlobalVars
-          end
-          alias key? include?
-        end
-
-        java_import org.openhab.core.items.GroupItem
-        # Fetches all non-group items from the item registry
-        # @return [OpenHAB::Core::DSL::Items::Items]
-        def items
-          # rubocop: disable Style/GlobalVars
-          Items.new(EntityLookup.decorate_items($ir.items.reject { |item| item.is_a? GroupItem }))
-          # rubocop: enable Style/GlobalVars
-        end
-      end
-    end
-  end
-end

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

@@ -1,323 +0,0 @@
-# frozen_string_literal: true
-
-require 'bigdecimal'
-require 'forwardable'
-require 'java'
-require 'openhab/core/dsl/types/quantity'
-
-module OpenHAB
-  module Core
-    module DSL
-      module Items
-        #
-        # Delegation to OpenHAB Number Item
-        #
-        # rubocop: disable Metrics/ClassLength
-        # Disabled because this class has a single responsibility, there does not appear a logical
-        # way of breaking it up into multiple classes
-        class NumberItem < Numeric
-          extend Forwardable
-
-          def_delegator :@number_item, :to_s
-
-          java_import org.openhab.core.library.types.DecimalType
-          java_import org.openhab.core.library.types.QuantityType
-          java_import 'tec.uom.se.format.SimpleUnitFormat'
-          java_import 'tec.uom.se.AbstractUnit'
-
-          #
-          # Create a new NumberItem
-          #
-          # @param [Java::Org::openhab::core::library::items::NumberItem] number_item OpenHAB number item to delegate to
-          #
-          def initialize(number_item)
-            @number_item = number_item
-            super()
-          end
-
-          #
-          # Check if NumberItem is truthy? as per defined by library
-          #
-          # @return [Boolean] True if item is not in state UNDEF or NULL and value is not zero.
-          #
-          def truthy?
-            @number_item.state? && @number_item.state != DecimalType::ZERO
-          end
-
-          #
-          # Coerce objects into a NumberItem
-          #
-          # @param [Object] other object to coerce to a NumberItem if possible
-          #
-          # @return [Object] NumberItem, QuantityTypes, BigDecimal or nil depending on NumberItem configuration
-          #  and/or supplied object
-          #
-          def coerce(other)
-            logger.trace("Coercing #{self} as a request from  #{other.class}")
-            case other
-            when Quantity then coerce_from_quantity(other)
-            when Numeric then  coerce_from_numeric(other)
-            else
-              logger.trace("#{self} cannot be coerced to #{other.class}")
-              nil
-            end
-          end
-
-          #
-          # Compare NumberItem 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.
-          #
-          # rubocop: disable Metrics/AbcSize
-          def <=>(other)
-            logger.trace("NumberItem #{self} <=> #{other} (#{other.class})")
-            case other
-            when NumberItem then number_item_compare(other)
-            when Numeric then @number_item.state.to_big_decimal.to_d <=> other.to_d
-            when String then @number_item.state <=> QuantityType.new(other) if dimension
-            else
-              other = other.state if other.respond_to? :state
-              @number_item.state <=> other
-            end
-          end
-          # rubocop: enable Metrics/AbcSize
-
-          #
-          # Convert NumberItem to a Quantity
-          #
-          # @param [Object] other String or Unit representing an OpenHAB Unit
-          #
-          # @return [OpenHAB::Core::DSL::Types::Quantity] NumberItem converted to supplied Unit
-          #
-          def |(other)
-            other = SimpleUnitFormat.instance.unitFor(other) if other.is_a? String
-
-            if dimension
-              to_qt | other
-            else
-              Quantity.new(QuantityType.new(to_d.to_java, other))
-            end
-          end
-
-          #
-          # Convert NumberItem to a Quantity
-          #
-          # @return [OpenHAB::Core::DSL::Types::Quantity] NumberItem converted to a QuantityUnit
-          #
-          def to_qt
-            if dimension
-              Quantity.new(@number_item.get_state_as(QuantityType))
-            else
-              Quantity.new(QuantityType.new(to_d.to_java, AbstractUnit::ONE))
-            end
-          end
-
-          #
-          # Converts the NumberItem to an Integer
-          #
-          # @return [Integer] NumberItem as an integer
-          #
-          def to_i
-            to_d&.to_i
-          end
-
-          #
-          # Converts the NumberItem to a float
-          #
-          # @return [Float] NumberItem as a float
-          #
-          def to_f
-            to_d&.to_f
-          end
-
-          #
-          # Converts the NumberItem to a BigDecimal
-          #
-          # @return [BigDecimal] NumberItem as a BigDecimal
-          #
-          def to_d
-            @number_item.state.to_big_decimal.to_d if @number_item.state.respond_to? :to_big_decimal
-          end
-
-          #
-          # Get the Dimension attached to the NumberItem
-          #
-          # @return [Java::org::openhab::core::library::types::QuantityType] dimension
-          #
-          def dimension
-            @number_item.dimension
-          end
-
-          #
-          # Forward missing methods to Openhab Number 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 NumberItem
-          #
-          def method_missing(meth, *args, &block)
-            logger.trace("Method missing, performing dynamic lookup for: #{meth}")
-            if @number_item.respond_to?(meth)
-              @number_item.__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)
-            @number_item.respond_to?(method_name) ||
-              ::Kernel.method_defined?(method_name) ||
-              ::Kernel.private_method_defined?(method_name)
-          end
-
-          %w[+ - * /].each do |operation|
-            define_method(operation) do |other|
-              logger.trace("Execution math operation '#{operation}' on #{inspect} with #{other.inspect}")
-              left_operand, right_operand = operands_for_operation(other)
-              left_operand.public_send(operation, right_operand)
-            end
-          end
-
-          private
-
-          #
-          # Get the operands for any operation
-          #
-          # @param [Object] other object to convert to a compatible operand
-          #
-          # @return [Array[Object,Object]] of operands where the first value is the left operand
-          #   and the second value is the right operand
-          #
-          def operands_for_operation(other)
-            case other
-            when NumberItem then number_item_operands(other)
-            when Numeric then [to_d, other.to_d]
-            when String then string_operands(other)
-            else
-              return other.coerce(to_d) if other.respond_to? :coerce
-
-              raise ArgumentError, "#{other.class} can't be coerced into a NumberItem"
-            end
-          end
-
-          #
-          # Get operands for an operation when the right operand is provided as a string
-          #
-          # @param [String] other right operand
-          #
-          # @return [Array[QuantityType,QuantiyType]] of operands where the first value is the left operand
-          #   and the second value is the right operand
-          #
-          def string_operands(other)
-            return [to_qt, Quantity.new(other)] if dimension
-
-            raise ArgumentError, 'Strings are only valid operands if NumberItem is dimensions=ed.'
-          end
-
-          #
-          # Get operands for an operation when the right operand is provided is another number item
-          #
-          # @param [NumberItem] other right operand
-          #
-          # @return [Array<QuantityType,QuantityType>,Array<BigDecimal,BigDecimal>] of operands depending on
-          #   if the left or right operand has a dimensions
-          #
-          def number_item_operands(other)
-            if dimension || other.dimension
-              dimensioned_operands(other)
-            else
-              logger.trace("Both objects lack dimension, self='#{self}' other='#{other}'")
-              # If nothing has a dimension, just use BigDecimals
-              [to_d, other.to_d]
-            end
-          end
-
-          #
-          # Get operands for an operation when the left or right operand has a dimension
-          #
-          # @param [NumberItem] other right operand
-          #
-          # @return [Array<QuantityType,QuantityType>] of operands
-          #
-          def dimensioned_operands(other)
-            logger.trace("Dimensions self='#{dimension}' other='#{other.dimension}'")
-            if dimension
-              if other.dimension
-                # If both numbers have dimensions, do the math on the quantity types.
-                [to_qt, other.to_qt]
-              else
-                # If this number has dimension and the other does not,
-                # do math with this quantity type and the other as a big decimal
-                [to_qt, other]
-              end
-            else
-              # If this number has no dimension and the other does, convert this into a dimensionless quantity
-              [to_qt, other]
-            end
-          end
-
-          #
-          # Compare two number items, taking into account any dimensions
-          #
-          # @param [NumberItem] other number item
-          #
-          # @return [-1,0,1] depending on if other object is less than, equal to or greater than self
-          #
-          def number_item_compare(other)
-            if other.dimension
-              logger.trace('Other is dimensioned, converting self and other to QuantityTypes to compare')
-              to_qt <=> other.to_qt
-            else
-              @number_item.state <=> other.state
-            end
-          end
-
-          #
-          # Coerce from a numberic object depnding on dimension and state
-          #
-          # @param [Numeric] other numeric object to convert
-          #
-          # @return [Array<QuantityType,QuantityType>,Array<BigDecimal,BigDecimal>,nil] depending on
-          #   if this object has a dimension or state
-          #
-          def coerce_from_numeric(other)
-            if dimension
-              [Quantity.new(other), to_qt]
-            elsif @number_item.state?
-              [other.to_d, @number_item.state.to_big_decimal.to_d]
-            end
-          end
-
-          #
-          # Coerce when other is a quantity
-          #
-          # @param [QuantityType] other
-          #
-          # @return [Array<QuanityType,QuantityType] other and self as a quantity type
-          #
-          def coerce_from_quantity(other)
-            as_qt = to_qt
-            logger.trace("Converted #{self} to a Quantity #{as_qt}")
-            [other, as_qt]
-          end
-        end
-      end
-    end
-  end
-end
-# rubocop: enable Metrics/ClassLength