openhab-scripting 2.14.1 → 2.14.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6851ec9dce8db775e48aaf7d08078281e2a2e9c1d6a2c2cd379de0d3fd2391f0
-  data.tar.gz: 2f656d9cb621d3826c72c2aa588d1ba478108bc30cffd32bf8e0e5fae85dbe47
+  metadata.gz: cf896ff53247e4170a9d3c09ebd3b337114bcc8509963001f4ccea9a4c81d52f
+  data.tar.gz: 974c4e5175053de2818fa725de5376458f21a01bc45fb444ac4a6b82e84685bb
 SHA512:
-  metadata.gz: 248767b8ec14f2f68412f152755beb872b15b6db26b363cc0837419e16f044b8c6b078843cd93c4efe8fe03358256df7cb8d390ebe43ddb6ad00b962ecb197ce
-  data.tar.gz: 9bb8e09d8a34c96b220b16b209c92cf5fce0f1bd54f28086ed3f6e4ae83ab24b0288bb828d9b2111fec3fbef10025b70624b13005140690ce5a9b2556df1a132
+  metadata.gz: f3d966995bcf7d4d6ae5ff5a6567af8e47e57355d7ac438b46b236755205a6dbc955520f28734901f8e49b8d415b6a0497f82f1a89a698cc90d61363621d9396
+  data.tar.gz: 0a76fe6c623432d7203ddbac268690be10ff7c9bcdcd1a2b56ace1cda3ead34f036ee70cd7f66c695c284faba921f37b3e5bbf6a091b616b31a2ca94e1c4cb89

data/lib/openhab.rb

@@ -36,4 +36,7 @@ module OpenHAB
 end
 
 # Extend caller with OpenHAB methods
+
+# rubocop: disable Style/MixinUsage
 extend OpenHAB
+# rubocop: enable Style/MixinUsage

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

@@ -46,7 +46,7 @@ module OpenHAB
           # rubocop: disable Style/GlobalVars
           action_keys = $actions.action_keys
           # rubocop: enable Style/GlobalVars
-          logger.trace( "Registered actions: '#{action_keys}' for thing '#{thing_uid}'")
+          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)

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

@@ -4,6 +4,7 @@ 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'
 
@@ -25,6 +26,7 @@ end
 # Manages access to OpenHAB entities
 #
 module EntityLookup
+  include Logging
   #
   # Decorate items with Ruby wrappers
   #
@@ -32,14 +34,13 @@ module EntityLookup
   #
   # @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
-        group = item
-        item = OpenHAB::Core::DSL::Groups::Group.new(Set.new(EntityLookup.decorate_items(item.all_members.to_a)))
-        item.group = group
-        item
+        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
@@ -49,6 +50,7 @@ module EntityLookup
       end
     end
   end
+  # rubocop: enable Metrics/MethodLength
 
   #
   # Loops up a Thing in the OpenHAB registry replacing '_' with ':'
@@ -58,6 +60,7 @@ module EntityLookup
   # @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
 
@@ -78,6 +81,7 @@ module EntityLookup
   # @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)
@@ -98,6 +102,39 @@ module EntityLookup
     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/gems.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 
 require 'core/log'
-require 'bundler/inline'
+require 'bundler/inline'

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

@@ -28,7 +28,7 @@ module OpenHAB
           #
           def[](name)
             group = EntityLookup.lookup_item(name)
-            (group.is_a? Group) ? group : nil
+            group.is_a?(Group) ? group : nil
           end
         end
 
@@ -38,7 +38,9 @@ module OpenHAB
         # @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

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

@@ -21,7 +21,7 @@ module OpenHAB
             # rubocop: disable Style/GlobalVars
             item = $ir.getItem(name)
             # rubocop: enable Style/GlobalVars
-            (item.is_a? GroupItem) ? nil : item
+            item.is_a?(GroupItem) ? nil : item
           rescue Java::OrgOpenhabCoreItems::ItemNotFoundException
             nil
           end
@@ -30,7 +30,9 @@ module OpenHAB
           # @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

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

@@ -12,6 +12,9 @@ module OpenHAB
         #
         # 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
 
@@ -46,21 +49,14 @@ module OpenHAB
           #
           # @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
+          # @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
-              as_qt = to_qt
-              logger.trace("Converted #{self} to a Quantity #{as_qt}")
-              [other, as_qt]
-            when Numeric
-              if dimension
-                [Quantity.new(other), to_qt]
-              elsif @number_item.state?
-                [other.to_d, @number_item.state.to_big_decimal.to_d]
-              end
+            when Quantity then coerce_from_quantity(other)
+            when Numeric then  coerce_from_numeric(other)
             else
               logger.trace("#{self} cannot be coereced to #{other.class}")
               nil
@@ -72,22 +68,15 @@ 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)
             logger.trace("Comparing #{self} to #{other}")
             case other
-            when NumberItem
-              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
-            when Numeric
-              @number_item.state.to_big_decimal.to_d <=> other.to_d
-            when String
-              @number_item.state <=> QuantityType.new(other) if dimension
+            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
             end
           end
 
@@ -167,6 +156,7 @@ module OpenHAB
           # @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)
@@ -176,42 +166,153 @@ module OpenHAB
             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}")
-              if other.is_a? NumberItem
-                logger.trace('Math operations is between two NumberItems.')
-                if dimension && other.dimension
-                  # If both numbers have dimensions, do the math on the quantity types.
-                  logger.trace("Both objects have dimensions self='#{dimension}' other='#{other.dimension}'")
-                  to_qt.public_send(operation, other.to_qt)
-                elsif dimension && !other.dimension
-                  # If this number has dimension and the other does not, do math with this quantity type and the other as a big decimal
-                  logger.trace("Self has dimension self='#{dimension}' other lacks dimension='#{other}'")
-                  to_qt.public_send(operation, other)
-                elsif other.dimension
-                  # If this number has no dimension and the other does, convert this into a dimensionless quantity
-                  logger.trace("Self has no dimension self='#{self}' other has dimension='#{other.dimension}'")
-                  to_qt.public_send(operation, other)
-                else
-                  logger.trace("Both objects lack dimension, self='#{self}' other='#{other}'")
-                  # If nothing has a dimension, just use BigDecimals
-                  to_d.public_send(operation, other.to_d)
-                end
-              elsif other.is_a? Numeric
-                to_d.public_send(operation, other.to_d)
-              elsif dimension && other.is_a?(String)
-                to_qt.public_send(operation, Quantity.new(other))
-              elsif other.respond_to? :coerce
-                a, b = other.coerce(to_d)
-                a.public_send(operation, b)
+              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
-                raise TypeError, "#{other.class} can't be coerced into a NumberItem"
+                # 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

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
@@ -87,7 +90,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 +98,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