openhab-scripting 2.14.1 → 2.16.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6851ec9dce8db775e48aaf7d08078281e2a2e9c1d6a2c2cd379de0d3fd2391f0
-  data.tar.gz: 2f656d9cb621d3826c72c2aa588d1ba478108bc30cffd32bf8e0e5fae85dbe47
+  metadata.gz: c15fe5aa4e28a32decf98e69c4565e8bb9667e40c34e9d06e1a314423ce7256d
+  data.tar.gz: 50099ece4197b4ed58d48b75ca454f5c0e44e158464ae74730848da919d5b292
 SHA512:
-  metadata.gz: 248767b8ec14f2f68412f152755beb872b15b6db26b363cc0837419e16f044b8c6b078843cd93c4efe8fe03358256df7cb8d390ebe43ddb6ad00b962ecb197ce
-  data.tar.gz: 9bb8e09d8a34c96b220b16b209c92cf5fce0f1bd54f28086ed3f6e4ae83ab24b0288bb828d9b2111fec3fbef10025b70624b13005140690ce5a9b2556df1a132
+  metadata.gz: 43375143a4d64557961a18e653b1fb75c164c2becdb57464ed5ba71200b9110a11d13d0a1c8f0fa493efcaea51e234257f07c622dd3672c79c48f9b4bd6b7d35
+  data.tar.gz: 002cd1958a0102b1a5a975a17ff98a64d57b529fb2255118d232572a4a20e75d9ddbbef51a50cb927e4e85a4cc6ef4d05e7cf64e16f4730885619a55f34afea4

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.rb

@@ -19,6 +19,7 @@ require 'core/dsl/gems'
 require 'core/dsl/units'
 require 'core/dsl/types/quantity'
 require 'core/dsl/states'
+require 'core/dsl/persistence'
 
 module OpenHAB
   #
@@ -30,6 +31,7 @@ module OpenHAB
     #
     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
@@ -40,8 +42,10 @@ module OpenHAB
         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

@@ -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,23 +49,16 @@ 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}")
+              logger.trace("#{self} cannot be coerced to #{other.class}")
               nil
             end
           end
@@ -72,24 +68,22 @@ 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.
           #
+          # rubocop: disable Metrics/AbcSize
           def <=>(other)
-            logger.trace("Comparing #{self} to #{other}")
+            logger.trace("NumberItem #{self} <=> #{other} (#{other.class})")
             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
+            else
+              other = other.state if other.respond_to? :state
+              @number_item.state <=> other
             end
           end
+          # rubocop: enable Metrics/AbcSize
 
           #
           # Convert NumberItem to a Quantity
@@ -167,6 +161,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 +171,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