openhab-scripting 2.12.0 → 2.14.2

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

@@ -4,8 +4,6 @@ require 'java'
 require 'delegate'
 require 'forwardable'
 
-require 'core/duration'
-
 module OpenHAB
   module Core
     module DSL
@@ -41,15 +39,11 @@ module OpenHAB
             # occurs before the @timer variable can be set resulting in @timer being nil
             semaphore = Mutex.new
 
-            @block = proc do
-              semaphore.synchronize do
-                block.call(self)
-              end
-            end
+            timer_block = proc { semaphore.synchronize { block.call(self) } }
 
             semaphore.synchronize do
               @timer = ScriptExecution.createTimer(
-                ZonedDateTime.now.plus(Java::JavaTime::Duration.ofMillis(@duration.to_ms)), @block
+                ZonedDateTime.now.plus(@duration), timer_block
               )
               super(@timer)
             end
@@ -64,7 +58,7 @@ module OpenHAB
           #
           def reschedule(duration = nil)
             duration ||= @duration
-            @timer.reschedule(ZonedDateTime.now.plus(Java::JavaTime::Duration.ofMillis(duration.to_ms)))
+            @timer.reschedule(ZonedDateTime.now.plus(duration))
           end
         end
 

data/lib/openhab/core/dsl/types/quantity.rb

@@ -13,6 +13,9 @@ module OpenHAB
         #
         # Ruby implementation for OpenHAB quantities
         #
+        # 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 Quantity < Numeric
           extend Forwardable
           include Logging
@@ -23,6 +26,7 @@ module OpenHAB
           java_import 'tec.uom.se.format.SimpleUnitFormat'
           java_import 'tec.uom.se.AbstractUnit'
 
+          # @return [Hash] Mapping of operation symbols to BigDecimal methods
           OPERATIONS = {
             '+' => 'add',
             '-' => 'subtract',
@@ -37,18 +41,15 @@ module OpenHAB
           #
           # Create a new Quantity
           #
-          # @param [Java::org::openhab::core::library::types::QuantityType] quantity OpenHAB quantity to delegate to
+          # @param [object] quantity String,QuantityType or Numeric to be this quantity
           #
+          # Cop disabled, case statement is compact and idiomatic
           def initialize(quantity)
             @quantity = case quantity
-                        when String
-                          QuantityType.new(quantity)
-                        when QuantityType
-                          quantity
-                        when Numeric
-                          QuantityType.new(BigDecimal(quantity).to_java, AbstractUnit::ONE)
-                        else
-                          raise "Unexpected type #{quantity.class} provided to Quantity initializer"
+                        when String then QuantityType.new(quantity)
+                        when QuantityType then quantity
+                        when NumberItem, Numeric then QuantityType.new(quantity.to_d.to_java, AbstractUnit::ONE)
+                        else raise ArgumentError, "Unexpected type #{quantity.class} provided to Quantity initializer"
                         end
             super()
           end
@@ -76,20 +77,8 @@ module OpenHAB
           #
           def <=>(other)
             logger.trace("Comparing #{self} to #{other}")
-            case other
-            when Quantity
-              logger.trace("Comparing Quantity #{self} to Quantity #{other}")
-              convert_unit(quantity).compare_to(convert_unit(other.quantity))
-            when QuantityType
-              other = convert_unit(other)
-              quantity.compare_to(other)
-            when String
-              other = QuantityType.new(other)
-              other = convert_unit(other)
-              quantity.compare_to(other)
-            when Numeric
-              quantity.compare_to(QuantityType.new(other, unit)) if unit
-            end
+            my_qt, other_qt = unitize(*to_qt(coerce(other).reverse))
+            my_qt.compare_to(other_qt)
           end
 
           #
@@ -100,14 +89,12 @@ module OpenHAB
           # @return [Array] of self and other object as Quantity types, nil if object cannot be coerced
           #
           def coerce(other)
-            logger.trace("Coercing #{self} as a request from  #{other.class}")
+            logger.trace("Coercing #{self} as a request from #{other.class}")
             case other
-            when Quantity
-              [other.quantity, quantity]
-            when QuantityType
-              [other, quantity]
-            when Numeric
-              [Quantity.new(other), self]
+            when Quantity then [other.quantity, quantity]
+            when QuantityType then [other, quantity]
+            when NumberItem then [other.to_qt.quantity, quantity]
+            when Numeric, String then [Quantity.new(other), self]
             end
           end
 
@@ -121,6 +108,7 @@ module OpenHAB
           # @return [Object] result of delegation
           #
           def method_missing(meth, *args, &block)
+            logger.trace("Method missing, performing dynamic lookup for: #{meth}")
             if quantity.respond_to?(meth)
               quantity.__send__(meth, *args, &block)
             elsif ::Kernel.method_defined?(meth) || ::Kernel.private_method_defined?(meth)
@@ -130,6 +118,20 @@ 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)
+            quantity.respond_to?(method_name) ||
+              ::Kernel.method_defined?(method_name) ||
+              ::Kernel.private_method_defined?(method_name)
+          end
+
           #
           # Negate the quantity
           #
@@ -141,22 +143,10 @@ module OpenHAB
 
           OPERATIONS.each do |operation, method|
             define_method(operation) do |other|
-              logger.trace("Executing math operation '#{operation}' on quantity #{inspect} with other type #{other.class} and value #{other.inspect}")
-              a, b = case other
-                     when Quantity
-                       [quantity, other.quantity]
-                     when String
-                       [quantity, QuantityType.new(other)]
-                     when NumberItem
-                       a, b = other.coerce(self)
-                       logger.trace("Number Item coerced result a(#{a.class})='#{a}' b(#{b.class})='#{b}'")
-                       [a.quantity, b.quantity]
-                     when Numeric
-                       [quantity, QuantityType.new(BigDecimal(other).to_java, AbstractUnit::ONE)]
-                     else
-                       raise TypeError,
-                             "Operation '#{operation}' cannot be performed between #{self} and #{other.class}"
-                     end
+              logger.trace("Executing math operation '#{operation}' on quantity #{inspect} "\
+                           "with other type #{other.class} and value #{other.inspect}")
+
+              a, b = to_qt(coerce(other).reverse)
               logger.trace("Coerced a='#{a}' with b='#{b}'")
               a, b = unitize(a, b, operation)
               logger.trace("Unitized a='#{a}' b='#{b}'")
@@ -180,10 +170,22 @@ module OpenHAB
 
           private
 
+          # @return [Array] Array of strings for operations for which the operands will not be unitized
           DIMENSIONLESS_NON_UNITIZED_OPERATIONS = %w[* /].freeze
 
           # Dimensionless numbers should only be unitzed for addition and subtraction
 
+          #
+          # Convert one or more Quantity obects to the underlying quantitytypes
+          #
+          # @param [Array] quanities Array of either Quantity or QuantityType objects
+          #
+          # @return [Array]  Array of QuantityType objects
+          #
+          def to_qt(*quanities)
+            [quanities].flatten.compact.map { |item| item.is_a?(Quantity) ? item.quantity : item }
+          end
+
           #
           # Checks if an item should be unitized
           #
@@ -193,11 +195,7 @@ module OpenHAB
           # @return [Boolean] True if the quantity should be unitzed based on the unit and operation, false otherwise
           #
           def unitize?(quantity, operation)
-            if quantity.unit == AbstractUnit::ONE && DIMENSIONLESS_NON_UNITIZED_OPERATIONS.include?(operation)
-              false
-            else
-              true
-            end
+            !(quantity.unit == AbstractUnit::ONE && DIMENSIONLESS_NON_UNITIZED_OPERATIONS.include?(operation))
           end
 
           #
@@ -208,36 +206,65 @@ module OpenHAB
           # @return [Quantity] Quantity coverted to unit set by unit block
           #
           def convert_unit(quantity)
-            if unit
-              case quantity.unit
-              when AbstractUnit::ONE
-                logger.trace("Converting dimensionless #{quantity} to #{unit}")
-                QuantityType.new(quantity.to_big_decimal, unit)
-              when unit
-                quantity
-              else
-                logger.trace("Converting dimensioned item #{inspect} to #{unit}")
-                converted = quantity.to_unit(unit)
-                raise "Conversion from #{quantity.unit} to #{unit} failed" if converted.nil?
-
-                converted
-              end
-            else
+            return quantity unless unit?
+
+            case quantity.unit
+            when unit
               quantity
+            when AbstractUnit::ONE
+              convert_unit_from_dimensionless(quantity, unit)
+            else
+              convert_unit_from_dimensioned(quantity, unit)
             end
           end
 
+          #
+          # Converts a dimensioned quantity to a specific unit
+          #
+          # @param [Quantity] quantity to convert
+          # @param [Unit] unit to convert to
+          #
+          # @return [Java::org::openhab::core::library::types::QuantityType] converted quantity
+          #
+          def convert_unit_from_dimensioned(quantity, unit)
+            logger.trace("Converting dimensioned item #{inspect} to #{unit}")
+            quantity.to_unit(unit).tap do |converted|
+              raise "Conversion from #{quantity.unit} to #{unit} failed" unless converted
+            end
+          end
+
+          #
+          # Converts a dimensionless quantity to a unit
+          #
+          # @param [Quantity] quantity to convert
+          # @param [Unit] unit to convert to
+          #
+          # @return [Java::org::openhab::core::library::types::QuantityType] converted quantity
+          #
+          def convert_unit_from_dimensionless(quantity, unit)
+            logger.trace("Converting dimensionless #{quantity} to #{unit}")
+            QuantityType.new(quantity.to_big_decimal, unit)
+          end
+
           #
           # Convert quantities to appropriate units
           #
           # @param [Quantity] quantity_a Quantity on left side of operation
           # @param [Quantity] quantity_b Quantity on right side of operation
           # @param [String] operation Math operation
+          # @yield [quantity_a, quantity_b] yields unitized versions of supplied quantities
           #
-          # @return [Array] of quantites in correct units for the supplied operation and set unit
+          # @return [Array, Object] of quantites in correct units for the supplied operation and the unit
+          #   or the result of the block if a block is given
           #
-          def unitize(quantity_a, quantity_b, operation)
-            [quantity_a, quantity_b].map { |qt| unitize?(qt, operation) ? convert_unit(qt) : qt }
+          def unitize(quantity_a, quantity_b, operation = nil)
+            logger.trace("Unitizing (#{quantity_a}) and (#{quantity_b})")
+            quantity_a, quantity_b = [quantity_a, quantity_b].map do |qt|
+              unitize?(qt, operation) ? convert_unit(qt) : qt
+            end
+            return yield quantity_a, quantity_b if block_given?
+
+            [quantity_a, quantity_b]
           end
 
           #
@@ -248,8 +275,18 @@ module OpenHAB
           def unit
             Thread.current.thread_variable_get(:unit)
           end
+
+          #
+          # Is a unit set for this thread
+          #
+          # @return [boolean] true if a unit is set by this thread, false otherwise
+          #
+          def unit?
+            unit != nil
+          end
         end
       end
     end
   end
 end
+# rubocop: enable Metrics/ClassLength

data/lib/openhab/core/log.rb

@@ -44,7 +44,8 @@ module Logging
     # Log a message to the OpenHAB Logger
     #
     # @param [Symbol] severity Severity to log message at
-    # @param [Object] msg to log, if no msg supplied and a block is provided, the msg is taken from the result of the block
+    # @param [Object] msg to log, if no msg supplied and a block is provided,
+    #   the msg is taken from the result of the block
     #
     def log(severity:, msg: nil)
       severity = severity.to_sym
@@ -55,13 +56,7 @@ module Logging
       return unless @sl4fj_logger.send("is_#{severity.to_s.downcase}_enabled")
 
       # Process block if no message provided
-      if msg.nil?
-        if block_given?
-          msg = yield
-        else
-          return
-        end
-      end
+      msg = yield if msg.nil? && block_given?
 
       msg = message_to_string(msg: msg)
 

data/lib/openhab/core/startup_delay.rb

@@ -8,6 +8,7 @@ require 'core/log'
 module StartupDelay
   include Logging
 
+  # @return [Integer] Number of seconds to wait between checks for automation manager
   CHECK_DELAY = 10
   private_constant :CHECK_DELAY
 

data/lib/openhab/osgi.rb

@@ -38,6 +38,11 @@ module OpenHAB
       end
     end
 
+    #
+    # Get the bundle context
+    #
+    # @return [java::org::osgi::framework::BundleContext] OSGI bundle context
+    #
     def self.bundle_context
       @bundle_context ||= bundle.getBundleContext
     end
@@ -45,7 +50,9 @@ module OpenHAB
 
     # Get the OSGI Bundle for ScriptExtension Class
     def self.bundle
+      # rubocop: disable Style/GlobalVars
       @bundle ||= FrameworkUtil.getBundle($scriptExtension.class)
+      # rubocop: enable Style/GlobalVars
     end
     private_class_method :bundle
   end

data/lib/openhab/version.rb

@@ -5,5 +5,5 @@
 #
 module OpenHAB
   # @return [String] Version of OpenHAB helper libraries
-  VERSION = '2.12.0'
+  VERSION = '2.14.2'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openhab-scripting
 version: !ruby/object:Gem::Version
-  version: 2.12.0
+  version: 2.14.2
 platform: ruby
 authors:
 - Brian O'Connell
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-02-02 00:00:00.000000000 Z
+date: 2021-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -64,19 +64,22 @@ files:
 - lib/openhab/core/dsl/monkey_patch/types/percent_type.rb
 - lib/openhab/core/dsl/monkey_patch/types/types.rb
 - lib/openhab/core/dsl/property.rb
-- lib/openhab/core/dsl/rule/channel.rb
-- lib/openhab/core/dsl/rule/cron.rb
+- lib/openhab/core/dsl/rule/automation_rule.rb
 - lib/openhab/core/dsl/rule/guard.rb
-- lib/openhab/core/dsl/rule/item.rb
 - lib/openhab/core/dsl/rule/rule.rb
-- lib/openhab/core/dsl/rule/triggers.rb
+- lib/openhab/core/dsl/rule/rule_config.rb
+- lib/openhab/core/dsl/rule/triggers/changed.rb
+- lib/openhab/core/dsl/rule/triggers/channel.rb
+- lib/openhab/core/dsl/rule/triggers/command.rb
+- lib/openhab/core/dsl/rule/triggers/cron.rb
+- lib/openhab/core/dsl/rule/triggers/trigger.rb
+- lib/openhab/core/dsl/rule/triggers/updated.rb
 - lib/openhab/core/dsl/states.rb
 - lib/openhab/core/dsl/things.rb
 - lib/openhab/core/dsl/time_of_day.rb
 - lib/openhab/core/dsl/timers.rb
 - lib/openhab/core/dsl/types/quantity.rb
 - lib/openhab/core/dsl/units.rb
-- lib/openhab/core/duration.rb
 - lib/openhab/core/log.rb
 - lib/openhab/core/patch_load_path.rb
 - lib/openhab/core/startup_delay.rb

data/lib/openhab/core/dsl/rule/item.rb

@@ -1,208 +0,0 @@
-# frozen_string_literal: true
-
-require 'core/log'
-require 'core/dsl/group'
-require 'core/dsl/things'
-require 'core/dsl/rule/triggers'
-require 'openhab/core/dsl/rule/triggers'
-
-module OpenHAB
-  module Core
-    module DSL
-      module Rule
-        #
-        # Triggers for items in rules
-        #
-        module Item
-          include Logging
-          include OpenHAB::Core::DSL::Rule
-          include OpenHAB::Core::DSL::Groups
-          include OpenHAB::Core::DSL::Things
-
-          #
-          # Struct capturing data necessary for a conditional trigger
-          #
-          TriggerDelay = Struct.new(:to, :from, :duration, :timer, :tracking_to, keyword_init: true)
-
-          #
-          # Create a TriggerDelay for for an item or group that is changed for a specific duration
-          #
-          # @param [Object] item to create trigger delay for
-          # @param [OpenHAB::Core::Duration] duration to delay trigger for until condition is met
-          # @param [Item State] to OpenHAB Item State item or group needs to change to
-          # @param [Item State] from OpenHAB Item State item or group needs to be coming from
-          #
-          # @return [Array] Array of current TriggerDelay objects
-          #
-          def changed_wait(item, duration:, to: nil, from: nil)
-            # Convert to testing the group if group specified rather than item
-            item = item.group if item.is_a? Group
-
-            # If GroupItems specified, use the group state trigger instead
-            if item.is_a? GroupItems
-              config = { 'groupName' => item.group.name }
-              trigger = Trigger::GROUP_STATE_CHANGE
-            else
-              config = { 'itemName' => item.name }
-              trigger = Trigger::ITEM_STATE_CHANGE
-            end
-            logger.trace("Creating Changed Wait Change Trigger for #{config}")
-            trigger = append_trigger(trigger, config)
-            @trigger_delays = { trigger.id => TriggerDelay.new(to: to, from: from, duration: duration) }
-          end
-
-          #
-          # Create a trigger for when an item or group receives a command
-          #
-          # The commands/commands parameters are replicated for DSL fluency
-          #
-          # @param [Array] items Array of items to create trigger for
-          # @param [Array] command commands to match for trigger
-          # @param [Array] commands commands to match for trigger
-          #
-          #
-          def received_command(*items, command: nil, commands: nil)
-            items.flatten.each do |item|
-              logger.trace("Creating received command trigger for item(#{item}) command(#{command}) commands(#{commands})")
-
-              # Combine command and commands, doing union so only a single nil will be in the combined array.
-              combined_commands = ([command] | [commands]).flatten
-
-              # If either command or commands has a value and one is nil, we need to remove nil from the array.
-              # If it is only now a single nil value, we leave the nil in place, so that we create a trigger
-              # That isn't looking for a specific command.
-              combined_commands = combined_commands.compact unless combined_commands.all?(&:nil?)
-
-              combined_commands.each do |cmd|
-                if item.is_a? GroupItems
-                  config = { 'groupName' => item.group.name }
-                  trigger = Trigger::GROUP_COMMAND
-                else
-                  config = { 'itemName' => item.name }
-                  trigger = Trigger::ITEM_COMMAND
-                end
-                config['command'] = cmd.to_s unless cmd.nil?
-                append_trigger(trigger, config)
-              end
-            end
-          end
-
-          #
-          # Create a trigger when item, group or thing is updated
-          #
-          # @param [Array] items array to trigger on updated
-          # @param [State] to to match for tigger
-          #
-          # @return [Trigger] Trigger for updated entity
-          #
-          def updated(*items, to: nil)
-            items.flatten.each do |item|
-              item = item.group if item.is_a? Group
-              logger.trace("Creating updated trigger for item(#{item}) to(#{to})")
-              [to].flatten.each do |to_state|
-                case item
-                when GroupItems
-                  config = { 'groupName' => item.group.name }
-                  config['state'] = to_state.to_s unless to_state.nil?
-                  trigger = Trigger::GROUP_STATE_UPDATE
-                when Thing
-                  trigger, config = trigger_for_thing(item, Trigger::THING_UPDATE, to_state)
-                else
-                  config = { 'itemName' => item.name }
-                  config['state'] = to_state.to_s unless to_state.nil?
-                  trigger = Trigger::ITEM_STATE_UPDATE
-                end
-                append_trigger(trigger, config)
-              end
-            end
-          end
-
-          #
-          # Creates a trigger item, group and thing changed
-          #
-          # @param [Object] items array of objects to create trigger for
-          # @param [to] to state for object to change for
-          # @param [from] from <description>
-          # @param [OpenHAB::Core::Duration] for Duration to delay trigger until to state is met
-          #
-          # @return [Trigger] OpenHAB trigger
-          #
-          def changed(*items, to: nil, from: nil, for: nil)
-            items.flatten.each do |item|
-              item = item.group if item.is_a? Group
-              logger.trace("Creating changed trigger for entity(#{item}), to(#{to}), from(#{from})")
-              # for is a reserved word in ruby, so use local_variable_get :for
-              if (wait_duration = binding.local_variable_get(:for))
-                changed_wait(item, to: to, from: from, duration: wait_duration)
-              else
-                # Place in array and flatten to support multiple to elements or single or nil
-                [to].flatten.each do |to_state|
-                  case item
-                  when GroupItems
-                    config = { 'groupName' => item.group.name }
-                    config['state'] = to_state.to_s if to_state
-                    config['previousState'] = from.to_s if from
-                    trigger = Trigger::GROUP_STATE_CHANGE
-                  when Thing
-                    trigger, config = trigger_for_thing(item, Trigger::THING_CHANGE, to_state, from)
-                  else
-                    config = { 'itemName' => item.name }
-                    config['state'] = to_state.to_s if to_state
-                    config['previousState'] = from.to_s if from
-                    trigger = Trigger::ITEM_STATE_CHANGE
-                  end
-                  append_trigger(trigger, config)
-                end
-              end
-            end
-          end
-
-          private
-
-          #
-          # Append a trigger to the list of triggeres
-          #
-          # @param [String] type of trigger to create
-          # @param [Map] config map describing trigger configuration
-          #
-          # @return [Trigger] OpenHAB trigger
-          #
-          def append_trigger(type, config)
-            logger.trace("Creating trigger of type #{type} for #{config}")
-            trigger = Trigger.trigger(type: type, config: config)
-            @triggers << trigger
-            trigger
-          end
-
-          #
-          # Create a trigger for a thing
-          #
-          # @param [Thing] thing to create trigger for
-          # @param [Trigger] trigger to map with thing
-          # @param [State] to for thing
-          # @param [State] from state of thing
-          #
-          # @return [Array] Trigger and config for thing
-          #
-          def trigger_for_thing(thing, trigger, to = nil, from = nil)
-            config = { 'thingUID' => thing.uid.to_s }
-            config['status'] = trigger_state_from_symbol(to).to_s if to
-            config['previousStatus'] = trigger_state_from_symbol(from).to_s if from
-            [trigger, config]
-          end
-
-          #
-          # converts object to upcase string if its a symbol
-          #
-          # @param [sym] sym potential symbol to convert
-          #
-          # @return [String] Upcased symbol as string
-          #
-          def trigger_state_from_symbol(sym)
-            sym.to_s.upcase if (sym.is_a? Symbol) || sym
-          end
-        end
-      end
-    end
-  end
-end