openhab-scripting 2.13.1 → 2.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '089e0d97f175f04c563675de122c80d0f5988be5ea38be8833736e4e73341a75'
-  data.tar.gz: 4b98810dd2e4f01772272fc10e457b57e81ade54c19b1dc59a72afd85c368b5a
+  metadata.gz: e06a1b4a2697fe4ac5d03467fb324ce1cf4d6e674946a7d96dae8928974b2460
+  data.tar.gz: 522268dcd796de02ee8dde9417d5a044dab87ef8a8d8100957268fc544443d3b
 SHA512:
-  metadata.gz: 67abc23128c151fdeb509f7a6c770696e0221b6a41a6e8af36628c891aa959c72e7ed7123d1e6d9711da3fe862eba2adaac9e3692e1026193cc7638e11de926a
-  data.tar.gz: 4348d10e590f9e8179c3559c05ae2417cd9a75150d069e98f1566316e60a5d5ed12b4057b0d67272e97d92c813cbf337c97dac8d69b1cc5538b06576aa3084f7
+  metadata.gz: 51ea02b7ccc10fc831a17627e31f0b0d7e250e778a08c8e7d226118c61cb98a07761eabee1299e9c6a4a83e949b448c20f1c7ebb7e5877939b601f1108929cec
+  data.tar.gz: 1ea8435d4826e815c212e422e714ac0480266b2ebc283c4471116cf08f45b3336758c75a1b74d00d631f1c7b729e078620dd72d4e9b853465eee06010e2ea027

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,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?
-                [BigDecimal(other), @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 <=> BigDecimal(other)
-            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, BigDecimal(other))
-              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