openhab-scripting 4.4.0 → 4.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a39d84f4797ad4d9807e581919e5a681e0b6ba52df5a64f395bc2409cb2d7f38
-  data.tar.gz: d56eb7cb6e9a3a50dd07407bed0a9be23f3b719b676c1e2d4bbf82685f049f73
+  metadata.gz: 287e243222ea07f7a3157b208722d47f489f14456713ad86401292f6b2fda942
+  data.tar.gz: 44968c29cf24415646ebb27ce64c3894966c4e9f9707edcd303eb89d4a4b1f04
 SHA512:
-  metadata.gz: 4bfda0871cefc7b2a0a95ea0d8528ab50111192727f4380f441c922eb5214573a59c9e0c7f39b9c13b26f9ee733607548445477f5b9a79ee7c1028cbbf064db6
-  data.tar.gz: 73002d6de64e98d48dd4f5b0a7ad0439c2bed9b15cdabfe36cffbf026930b0cdeac98da0b748e477362f28a19bdfdb2c0223749dbe6ae353ddc8a4e7b52341b6
+  metadata.gz: 12ce91f43449208a374b04ab92171a93c4ab3b68f2fee8ce7f948f7bf21f2be4a8d967b8f5758be957f5ca36cac831ebcb5f184204d650ed50d1fb345b1c2f7a
+  data.tar.gz: d7da5a64ab6aef028308a998ea83a77da1d77d12cbccb24c34875f6e51a9c6360e204efd75287de4d4f1fbc17b9bcd722057da227821f519452945fb17fd1666

data/lib/openhab/core/entity_lookup.rb

@@ -4,6 +4,8 @@ require 'pp'
 require 'java'
 require 'set'
 
+require 'openhab/log/logger'
+
 # Automation lookup and injection of OpenHab entities
 
 module OpenHAB
@@ -24,9 +26,6 @@ module OpenHAB
       # @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_entity(method) || super
       end

data/lib/openhab/core/script_handling.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'openhab/log/logger'
+require 'openhab/dsl/rules/rule'
+require 'openhab/dsl/timers'
+
+# OpenHAB main module
+module OpenHAB
+  module Core
+    #
+    # Manages script loading and unloading
+    #
+    module ScriptHandling
+      include OpenHAB::Log
+
+      #
+      # Executed when OpenHAB unloads a script file
+      #
+      # rubocop:disable Naming/MethodName
+      # method name dictacted by OpenHAB
+      def scriptUnloaded
+        logger.trace('Script unloaded')
+        OpenHAB::DSL::Rules.cleanup_rules
+        OpenHAB::DSL::Timers.cancel_all
+      end
+      # rubocop:enable Naming/MethodName
+
+      #
+      # Executed when OpenHAB loads a script file
+      #
+      # rubocop:disable Naming/MethodName
+      # method name dictacted by OpenHAB
+      def scriptLoaded(filename)
+        logger.trace("Script loaded: #{filename}")
+      end
+      # rubocop:enable Naming/MethodName
+    end
+  end
+end

data/lib/openhab/core/thread_local.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# OpenHAB main module
+module OpenHAB
+  module Core
+    #
+    # Manages thread local varaibles for access inside of blocks
+    #
+    module ThreadLocal
+      #
+      # Execute the supplied block with the supplied values set for the currently running thread
+      # The previous values for each key are restored after the block is executed
+      #
+      # @param [Hash] Keys and values to set for running thread
+      #
+      def thread_local(**values)
+        old_values = values.map { |key, _value| [key, Thread.current[key]] }.to_h
+        values.each { |key, value| Thread.current[key] = value }
+        yield
+      ensure
+        old_values.each { |key, value| Thread.current[key] = value }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+require_relative 'comparable_item'
+require 'openhab/dsl/types/hsb_type'
+
+module OpenHAB
+  module DSL
+    module Items
+      java_import org.openhab.core.library.items.ColorItem
+
+      # Adds methods to core OpenHAB ColorItem type to make it more natural in
+      # Ruby
+      class ColorItem < DimmerItem
+        extend Forwardable
+        include ComparableItem
+
+        # !@visibility private
+        def ==(other)
+          # need to check if we're referring to the same item before
+          # forwarding to <=> (and thus checking equality with state)
+          return true if equal?(other) || eql?(other)
+
+          super
+        end
+
+        #
+        # Type Coercion
+        #
+        # Coerce object to a HSBType
+        #
+        # @param [Types::HSBType, String] other object to coerce to a
+        #   HSBType
+        #
+        # @return [[Types::HSBType, Types::HSBType]]
+        #
+        def coerce(other)
+          logger.trace("Coercing #{self} as a request from #{other.class}")
+          return [other, nil] unless state?
+          return [other, state] if other.is_a?(Types::HSBType) || other.respond_to?(:to_str)
+
+          raise TypeError, "can't convert #{other.class} into #{self.class}"
+        end
+
+        # any method that exists on {Types::HSBType} gets forwarded to +state+
+        delegate (Types::HSBType.instance_methods - instance_methods) => :state
+
+        # string commands aren't allowed on ColorItems, so try to implicitly
+        # convert it to an HSBType
+        # @!visibility private
+        def format_type(command)
+          return Types::HSBType.new(command) if command.respond_to?(:to_str)
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'openhab/dsl/monkey_patch/events/item_command'
+require 'openhab/dsl/types/types'
 
 require_relative 'item_registry'
 
@@ -10,9 +11,11 @@ require_relative 'switch_item'
 require_relative 'date_time_item'
 require_relative 'dimmer_item'
 
+require_relative 'color_item'
 require_relative 'contact_item'
 require_relative 'group_item'
 require_relative 'image_item'
+require_relative 'location_item'
 require_relative 'number_item'
 require_relative 'player_item'
 require_relative 'rollershutter_item'
@@ -25,6 +28,8 @@ module OpenHAB
     # Contains all OpenHAB *Item classes, as well as associated support
     # modules
     module Items
+      include OpenHAB::Log
+
       class << self
         private
 
@@ -42,7 +47,7 @@ module OpenHAB
             _command_predicate, state_predicate = Types::PREDICATE_ALIASES[state.to_s]
             next if klass.instance_methods.include?(state_predicate)
 
-            OpenHAB::Core.logger.trace("Defining #{klass}##{state_predicate} for #{state}")
+            logger.trace("Defining #{klass}##{state_predicate} for #{state}")
             klass.class_eval <<~RUBY, __FILE__, __LINE__ + 1
               def #{state_predicate}   # def on?
                 raw_state == #{state}  #   raw_state == ON
@@ -58,21 +63,21 @@ module OpenHAB
             command = Types::COMMAND_ALIASES[value.to_s]
             next if klass.instance_methods.include?(command)
 
-            OpenHAB::Core.logger.trace("Defining #{klass}##{command} for #{value}")
+            logger.trace("Defining #{klass}##{command} for #{value}")
             klass.class_eval <<~RUBY, __FILE__, __LINE__ + 1
               def #{command}       # def on
                 command(#{value})  #   command(ON)
               end                  # end
             RUBY
 
-            OpenHAB::Core.logger.trace("Defining GroupItem::GroupMembers##{command} for #{value}")
+            logger.trace("Defining GroupItem::GroupMembers##{command} for #{value}")
             GroupItem::GroupMembers.class_eval <<~RUBY, __FILE__, __LINE__ + 1
               def #{command}        # def on
                 each(&:#{command})  #   each(&:on)
               end                   # end
             RUBY
 
-            OpenHAB::Core.logger.trace("Defining ItemCommandEvent##{command}? for #{value}")
+            logger.trace("Defining ItemCommandEvent##{command}? for #{value}")
             MonkeyPatch::Events::ItemCommandEvent.class_eval <<~RUBY, __FILE__, __LINE__ + 1
               def #{command}?        # def refresh?
                 command == #{value}  #   command == REFRESH

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+require_relative 'comparable_item'
+require 'openhab/dsl/types/point_type'
+
+module OpenHAB
+  module DSL
+    module Items
+      java_import org.openhab.core.library.items.LocationItem
+
+      # Adds methods to core OpenHAB NumberItem type to make it more natural in
+      # Ruby
+      class LocationItem < GenericItem
+        extend Forwardable
+        include ComparableItem
+
+        # !@visibility private
+        def ==(other)
+          # need to check if we're referring to the same item before
+          # forwarding to <=> (and thus checking equality with state)
+          return true if equal?(other) || eql?(other)
+
+          super
+        end
+
+        #
+        # Type Coercion
+        #
+        # Coerce object to a PointType
+        #
+        # @param [Types::PointType, String] other object to coerce to a
+        #   PointType
+        #
+        # @return [[Types::PointType, Types::PointType]]
+        #
+        def coerce(other)
+          logger.trace("Coercing #{self} as a request from #{other.class}")
+          return [other, nil] unless state?
+          return [other, state] if other.is_a?(Types::PointType) || other.respond_to?(:to_str)
+
+          raise TypeError, "can't convert #{other.class} into #{self.class}"
+        end
+
+        # OpenHAB has this method, but it _only_ accepts PointType, so remove it and delegate
+        remove_method :distance_from
+
+        # any method that exists on {Types::PointType} gets forwarded to +state+
+        delegate (Types::PointType.instance_methods - instance_methods) => :state
+      end
+    end
+  end
+end

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

@@ -15,10 +15,11 @@ module OpenHAB
         include ComparableItem
 
         # apply meta-programming methods to including class
+        # @!visibility private
         def self.included(klass)
           klass.prepend ItemEquality # make sure this is first
           klass.extend Forwardable
-          klass.delegate %i[+ - * / % | positive? negative? to_d to_f to_i to_int zero?] => :state
+          klass.delegate %i[+ - * / % | to_d to_f to_i to_int] => :state
           # remove the JRuby default == so that we can inherit the Ruby method
           klass.remove_method :==
         end
@@ -62,6 +63,16 @@ module OpenHAB
 
           super
         end
+
+        %i[positive? negative? zero?].each do |predicate|
+          class_eval <<~RUBY, __FILE__, __LINE__ + 1
+            def #{predicate}              # def positive?
+              return false unless state?  #   return false unless state?
+                                          #
+              state.#{predicate}          #   state.positive?
+            end                           # end
+          RUBY
+        end
       end
     end
   end

data/lib/openhab/dsl/monkey_patch/ruby/number.rb

@@ -91,7 +91,7 @@ module OpenHAB
 
             return super unless other.is_a?(javax.measure.Unit)
 
-            QuantityType.new(to_d.to_java, other)
+            Types::QuantityType.new(to_d.to_java, other)
           end
         end
       end

data/lib/openhab/dsl/rules/automation_rule.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
 require 'java'
+require 'set'
+require 'openhab/core/thread_local'
+require 'openhab/log/logger'
 
 module OpenHAB
   module DSL
@@ -16,6 +19,7 @@ module OpenHAB
       # way of breaking it up into multiple classes
       class AutomationRule < Java::OrgOpenhabCoreAutomationModuleScriptRulesupportSharedSimple::SimpleRule
         include OpenHAB::Log
+        include OpenHAB::Core::ThreadLocal
         include OpenHAB::DSL::TimeOfDay
         java_import java.time.ZonedDateTime
 
@@ -24,6 +28,7 @@ module OpenHAB
         #
         # @param [Config] config Rule configuration
         #
+        # Constructor sets a number of variables, no further decomposition necessary
         def initialize(config:)
           super()
           set_name(config.name)
@@ -59,6 +64,14 @@ module OpenHAB
           end
         end
 
+        #
+        # Cleanup any resources associated with automation rule
+        #
+        def cleanup
+          logger.trace "Cancelling #{@trigger_delays.length} Trigger Delays(s) for rule '#{name}'"
+          @trigger_delays.each_value { |trigger_delay| trigger_delay.timer&.cancel }
+        end
+
         private
 
         #

data/lib/openhab/dsl/rules/rule.rb

@@ -13,6 +13,12 @@ module OpenHAB
     # Creates and manages OpenHAB Rules
     #
     module Rules
+      @script_rules = []
+
+      class << self
+        attr_reader :script_rules
+      end
+
       #
       # Create a new rule
       #
@@ -45,6 +51,13 @@ module OpenHAB
         end
       end
 
+      #
+      # Cleanup rules in this script file
+      #
+      def self.cleanup_rules
+        @script_rules.each(&:cleanup)
+      end
+
       private
 
       #
@@ -67,6 +80,7 @@ module OpenHAB
         return unless create_rule?(config)
 
         rule = AutomationRule.new(config: config)
+        Rules.script_rules << rule
         add_rule(rule)
         rule.execute if config.on_start?
       end

data/lib/openhab/dsl/rules/rule_config.rb

@@ -26,7 +26,7 @@ module OpenHAB
       class RuleConfig
         include OpenHAB::Log
         include OpenHAB::Core::EntityLookup
-        include OpenHAB::DSL::Rules::Triggers
+        prepend OpenHAB::DSL::Rules::Triggers
         include OpenHAB::DSL::Rules::Guard
         include OpenHAB::DSL::Rules::Property
         extend OpenHAB::DSL

data/lib/openhab/dsl/time_of_day.rb

@@ -2,6 +2,7 @@
 
 require 'openhab/log/logger'
 require 'openhab/dsl/types/date_time_type'
+require 'openhab/dsl/items/items'
 require 'time'
 
 module OpenHAB

data/lib/openhab/dsl/timers.rb

@@ -3,6 +3,7 @@
 require 'java'
 require 'delegate'
 require 'forwardable'
+require 'openhab/log/logger'
 
 module OpenHAB
   module DSL
@@ -10,15 +11,23 @@ module OpenHAB
     # Provides access to and ruby wrappers around OpenHAB timers
     #
     module Timers
+      include OpenHAB::Log
       java_import org.openhab.core.model.script.actions.ScriptExecution
       java_import java.time.ZonedDateTime
 
+      # Tracks active timers
+      @timers = Set.new
+      class << self
+        attr_accessor :timers
+      end
+
       # Ruby wrapper for OpenHAB Timer
       # This class implements delegator to delegate methods to the OpenHAB timer
       #
       # @author Brian O'Connell
       # @since 2.0.0
       class Timer < SimpleDelegator
+        include OpenHAB::Log
         extend Forwardable
 
         def_delegator :@timer, :is_active, :active?
@@ -31,20 +40,19 @@ module OpenHAB
         # @param [Duration] duration Duration until timer should fire
         # @param [Block] block Block to execute when timer fires
         #
-        def initialize(duration:)
+        def initialize(duration:, &block)
           @duration = duration
 
           # A semaphore is used to prevent a race condition in which calling the block from the timer thread
           # occurs before the @timer variable can be set resulting in @timer being nil
           semaphore = Mutex.new
 
-          timer_block = proc { semaphore.synchronize { yield(self) } }
-
           semaphore.synchronize do
             @timer = ScriptExecution.createTimer(
-              ZonedDateTime.now.plus(@duration), timer_block
+              ZonedDateTime.now.plus(@duration), timer_block(semaphore, &block)
             )
             super(@timer)
+            Timers.timers << self
           end
         end
 
@@ -53,12 +61,40 @@ module OpenHAB
         #
         # @param [Duration] duration
         #
-        # @return [<Type>] <description>
+        # @return [Timer] Rescheduled timer instances
         #
         def reschedule(duration = nil)
           duration ||= @duration
+          Timers.timers << self
           @timer.reschedule(ZonedDateTime.now.plus(duration))
         end
+
+        # Cancel timer
+        #
+        # @return [Boolean] True if cancel was successful, false otherwise
+        #
+        def cancel
+          Timers.timers.delete(self)
+          @timer.cancel
+        end
+
+        private
+
+        #
+        # Constructs a block to execute timer within
+        #
+        # @param [Semaphore] Semaphore to obtain before executing
+        #
+        # @return [Proc] Block for timer to execute
+        #
+        def timer_block(semaphore)
+          proc {
+            semaphore.synchronize do
+              Timers.timers.delete(self)
+              yield(self)
+            end
+          }
+        end
       end
 
       #
@@ -72,6 +108,14 @@ module OpenHAB
       def after(duration, &block)
         Timer.new(duration: duration, &block)
       end
+
+      #
+      # Cancels all active timers
+      #
+      def self.cancel_all
+        logger.trace("Cancelling #{@timers.length} timers")
+        @timers.each(&:cancel)
+      end
     end
   end
 end

data/lib/openhab/dsl/types/hsb_type.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require_relative 'percent_type'
+
+module OpenHAB
+  module DSL
+    module Types
+      java_import org.openhab.core.library.types.HSBType
+
+      # global alias
+      ::HSBType = HSBType
+
+      # Adds methods to core OpenHAB HSBType to make it more natural in Ruby
+      class HSBType < PercentType
+        # @!parse BLACK = BLACK # @return [HSBType]
+        # @!parse WHITE = WHITE # @return [HSBType]
+        # @!parse RED = RED # @return [HSBType]
+        # @!parse GREEN = GREEN # @return [HSBType]
+        # @!parse BLUE = BLUE # @return [HSBType]
+
+        # conversion to QuantityType doesn't make sense on HSBType
+        undef_method :|
+
+        remove_method :==
+
+        # r, g, b as an array of symbols
+        RGB_KEYS = %i[r g b].freeze
+        private_constant :RGB_KEYS
+
+        class << self
+          # @!method from_rgb(r, g, b)
+          #   Create HSBType from RGB values
+          #   @param r [Integer] Red component (0-255)
+          #   @param g [Integer] Green component (0-255)
+          #   @param b [Integer] Blue component (0-255)
+          #   @return [HSBType]
+
+          # @!method from_xy(x, y)
+          #   Create HSBType representing the provided xy color values in CIE XY color model
+          #   @param x [Float]
+          #   @param y [Float]
+          #   @return [HSBType]
+
+          # Create HSBType from hue, saturation, and brightness values
+          # @param hue [DecimalType, QuantityType, Numeric] Hue component (0-360º)
+          # @param saturation [PercentType, Numeric] Saturation component (0-100%)
+          # @param brightness [PercentType, Numeric] Brightness component (0-100%)
+          # @return [HSBType]
+          def from_hsv(hue, saturation, brightness)
+            new(hue, saturation, brightness)
+          end
+
+          # add additional "overloads" to the constructor
+          # @!visibility private
+          def new(*args) # rubocop:disable Metrics
+            if args.length == 1 && args.first.respond_to?(:to_str)
+              value = args.first.to_str
+
+              # parse some formats OpenHAB doesn't understand
+              # in this case, HTML hex format for rgb
+              if (match = value.match(/^#(\h{2})(\h{2})(\h{2})$/))
+                rgb = match.to_a[1..3].map { |v| v.to_i(16) }
+                logger.trace("creating from rgb #{rgb.inspect}")
+                return from_rgb(*rgb)
+              end
+            end
+
+            return super unless args.length == 3
+
+            # convert from several numeric-like types to the exact types
+            # OpenHAB needs
+            hue = args[0]
+            args[0] = if hue.is_a?(DecimalType)
+                        hue
+                      elsif hue.is_a?(QuantityType)
+                        DecimalType.new(hue.to_unit(::Units::DEGREE_ANGLE).to_big_decimal)
+                      elsif hue.respond_to?(:to_d)
+                        DecimalType.new(hue)
+                      end
+            args[1..2] = args[1..2].map do |v|
+              if v.is_a?(PercentType)
+                v
+              elsif v.respond_to?(:to_d)
+                PercentType.new(v)
+              end
+            end
+
+            super(*args)
+          end
+        end
+
+        #
+        # Comparison
+        #
+        # @param [NumericType, Items::NumericItem, Items::ColorItem, Numeric, String]
+        #   other object to compare to
+        #
+        # @return [Integer, nil] -1, 0, +1 depending on whether +other+ is
+        #   less than, equal to, or greater than self
+        #
+        #   nil is returned if the two values are incomparable
+        #
+        def <=>(other)
+          logger.trace("(#{self.class}) #{self} <=> #{other} (#{other.class})")
+          if other.is_a?(Items::ColorItem) ||
+             (other.is_a?(Items::GroupItem) && other.base_item.is_a?(ColorItem))
+            return false unless other.state?
+
+            self <=> other.state
+          elsif other.respond_to?(:to_str)
+            self <=> HSBType.new(other)
+          else
+            super
+          end
+        end
+
+        #
+        # Type Coercion
+        #
+        # Coerce object to a HSBType
+        #
+        # @param [NumericType, Items::NumericItem, Items::ColorItem, Numeric, String]
+        #   other object to coerce to a HSBType
+        #
+        # @return [[HSBType, HSBType]]
+        #
+        def coerce(other)
+          logger.trace("Coercing #{self} as a request from #{other.class}")
+          if other.is_a?(Items::NumericItem) ||
+             (other.is_a?(Items::GroupItem) && other.base_item.is_a?(Items::NumericItem))
+            raise TypeError, "can't convert #{UnDefType} into #{self.class}" unless other.state?
+
+            [other.state, self]
+          elsif other.respond_to?(:to_str)
+            [HSBType.new(other.to_str), self]
+          else
+            super
+          end
+        end
+
+        # rename raw methods so we can overwrite them
+        # @!visibility private
+        alias raw_hue hue
+
+        # @!attribute [r] hue
+        # @return [QuantityType]
+        def hue
+          QuantityType.new(raw_hue.to_big_decimal, ::Units::DEGREE_ANGLE)
+        end
+
+        # Convert to a packed 32-bit RGB value representing the color in the default sRGB color model.
+        #
+        # The alpha component is always 100%.
+        #
+        # @return [Integer]
+        alias argb rgb
+
+        # Convert to a packed 24-bit RGB value representing the color in the default sRGB color model.
+        # @return [Integer]
+        def rgb
+          argb & 0xffffff
+        end
+
+        # Convert to an HTML-style string of 6 hex characters in the default sRGB color model.
+        # @return [String] +'#xxxxxx'+
+        def to_hex
+          Kernel.format('#%06x', rgb)
+        end
+
+        # include units
+        # @!visibility private
+        def to_s
+          "#{hue},#{saturation},#{brightness}"
+        end
+
+        # @!attribute [r] saturation
+        #   @return [PercentType]
+
+        # @!attribute [r] brightness
+        #   @return [PercentType]
+
+        # @!attribute [r] red
+        #   @return [PercentType]
+
+        # @!attribute [r] green
+        #   @return [PercentType]
+
+        # @!attribute [r] blue
+        #   @return [PercentType]
+
+        # @!method to_rgb
+        # Convert to RGB values representing the color in the default sRGB color model
+        # @return [[PercentType, PercentType, PercentType]]
+
+        # @!method to_xy
+        #   Convert to the xyY values representing this object's color in CIE XY color model
+        #   @return [[PercentType, PercentType]]
+      end
+    end
+  end
+end

data/lib/openhab/dsl/types/percent_type.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'decimal_type'
+
 module OpenHAB
   module DSL
     module Types

data/lib/openhab/dsl/types/point_type.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module DSL
+    module Types
+      java_import org.openhab.core.library.types.PointType
+
+      # global scope
+      # @!visibility private
+      ::PointType = PointType
+
+      # Adds methods to core OpenHAB PointType to make it more natural in Ruby
+      class PointType
+        # @!parse include PrimitiveType
+
+        # @param latitude [DecimalType, QuantityType, StringType, Numeric]
+        # @param longitude [DecimalType, QuantityType, StringType, Numeric]
+        # @param altitude [DecimalType, QuantityType, StringType, Numeric]
+        def initialize(*args) # rubocop:disable Metrics
+          if (2..3).cover?(args.length)
+            args = args.each_with_index.map do |value, index|
+              if value.is_a?(DecimalType) || value.is_a?(StringType)
+                value
+              elsif value.is_a?(QuantityType)
+                unit = index == 2 ? Units.unit || SIUnits::METRE : Units::DEGREE_ANGLE
+                DecimalType.new(value.to_unit(unit).to_big_decimal)
+              elsif value.respond_to?(:to_str)
+                StringType.new(value.to_str)
+              elsif value.respond_to?(:to_d)
+                DecimalType.new(value)
+              end
+            end
+          end
+
+          super(*args)
+        end
+
+        #
+        # Check equality without type conversion
+        #
+        # @return [Boolean] if the same value is represented, without type
+        #   conversion
+        def eql?(other)
+          return false unless other.instance_of?(self.class)
+
+          equals(other.to_s).zero?
+        end
+
+        #
+        # Check equality with type conversion
+        #
+        # @param [PointType, Items::LocationItem, String]
+        #   other object to compare to
+        #
+        # @return [Boolean]
+        #
+        def ==(other) # rubocop:disable Metrics
+          logger.trace("(#{self.class}) #{self} == #{other} (#{other.class})")
+          if other.is_a?(Items::LocationItem) ||
+             (other.is_a?(Items::GroupItem) && other.base_item.is_a?(LocationItem))
+            return false unless other.state?
+
+            self == other.state
+          elsif other.respond_to?(:to_str)
+            self == PointType.new(other)
+          elsif other.respond_to?(:coerce)
+            lhs, rhs = other.coerce(self)
+            lhs == rhs
+          end
+        end
+
+        #
+        # Type Coercion
+        #
+        # Coerce object to a PointType
+        #
+        # @param [Items::LocationItem, String] other object to coerce to a
+        #   PointType
+        #
+        # @return [[PointType, PointType]]
+        #
+        def coerce(other)
+          [coerce_single(other), self]
+        end
+
+        # rename raw methods so we can overwrite them
+        # @!visibility private
+        alias raw_latitude latitude
+        # .
+        # @!visibility private
+        alias raw_longitude longitude
+        # .
+        # @!visibility private
+        alias raw_altitude altitude
+        # .
+        # @!visibility private
+        alias raw_distance_from distance_from
+
+        # @!attribute [r] latitude
+        # @return [QuantityType]
+        def latitude
+          QuantityType.new(raw_latitude.to_big_decimal, SIUnits::DEGREE_ANGLE)
+        end
+
+        # @!attribute [r] longitude
+        # @return [QuantityType]
+        def longitude
+          QuantityType.new(raw_longitude.to_big_decimal, SIUnits::DEGREE_ANGLE)
+        end
+
+        # @!attribute [r] altitude
+        # @return [QuantityType]
+        def altitude
+          QuantityType.new(raw_altitude.to_big_decimal, Units::METRE)
+        end
+
+        #
+        # Calculate the distance in meters from other, ignoring altitude.
+        #
+        # This algorithm also ignores the oblate spheroid shape of Earth and
+        # assumes a perfect sphere, so results are inexact.
+        #
+        # @return [QuantityType]
+        def distance_from(other)
+          logger.trace("(#{self}).distance_from(#{other} (#{other.class})")
+          QuantityType.new(raw_distance_from(coerce_single(other)), SIUnits::METRE)
+        end
+        alias - distance_from
+
+        private
+
+        # coerce an object to a PointType
+        # @return [PointType]
+        def coerce_single(other) # rubocop:disable Metrics/MethodLength
+          logger.trace("Coercing #{self} as a request from #{other.class}")
+          if other.is_a?(PointType)
+            other
+          elsif other.is_a?(Items::LocationItem)
+            raise TypeError, "can't convert #{other.raw_state} into #{self.class}" unless other.state?
+
+            other.state
+          elsif other.respond_to?(:to_str)
+            PointType.new(other.to_str)
+          else
+            raise TypeError, "can't convert #{other.class} into #{self.class}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,15 +1,19 @@
 # frozen_string_literal: true
 
+require 'openhab/log/logger'
+
 require_relative 'type'
 
 require_relative 'date_time_type'
 require_relative 'decimal_type'
+require_relative 'hsb_type'
 require_relative 'increase_decrease_type'
 require_relative 'next_previous_type'
 require_relative 'open_closed_type'
 require_relative 'on_off_type'
 require_relative 'percent_type'
 require_relative 'play_pause_type'
+require_relative 'point_type'
 require_relative 'quantity_type'
 require_relative 'refresh_type'
 require_relative 'rewind_fastforward_type'
@@ -25,6 +29,8 @@ module OpenHAB
     # modules
     #
     module Types
+      include OpenHAB::Log
+
       # Hash taking a Enum value, and returning two symbols of
       # predicates to be defined for it. the first is the "command" form,
       # which should be defined on ItemCommandEvent, and on the Type itself.
@@ -63,7 +69,7 @@ module OpenHAB
           states = PREDICATE_ALIASES[value.to_s]
 
           ([command] | states).each do |method|
-            OpenHAB::Core.logger.trace("Defining #{klass}##{method} for #{value}")
+            logger.trace("Defining #{klass}##{method} for #{value}")
             klass.class_eval <<~RUBY, __FILE__, __LINE__ + 1
               def #{method}       # def on?
                 self == #{value}  #   self == ON

data/lib/openhab/version.rb

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

data/lib/openhab.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require 'openhab/core/load_path'
+require 'openhab/core/entity_lookup'
+require 'openhab/core/script_handling'
 require 'openhab/core/openhab_setup'
 require 'openhab/log/logger'
 require 'openhab/dsl/dsl'
@@ -17,9 +19,12 @@ module OpenHAB
   # @param [Object] base Object to decorate with DSL and helper methods
   #
   #
+  # rubocop:disable  Metrics/MethodLength
+  # Number of extensions and includes requires more lines
   def self.extended(base)
     OpenHAB::Core.wait_till_openhab_ready
     base.extend Log
+    base.extend OpenHAB::Core::ScriptHandling
     base.extend OpenHAB::Core::EntityLookup
     base.extend OpenHAB::DSL
     base.extend OpenHAB::DSL::TimeOfDay
@@ -31,6 +36,7 @@ module OpenHAB
 
     OpenHAB::Core.add_rubylib_to_load_path
   end
+  # rubocop:enable  Metrics/MethodLength
 end
 
 # Extend caller with OpenHAB methods

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openhab-scripting
 version: !ruby/object:Gem::Version
-  version: 4.4.0
+  version: 4.6.2
 platform: ruby
 authors:
 - Brian O'Connell
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-10-19 00:00:00.000000000 Z
+date: 2021-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -50,10 +50,13 @@ files:
 - lib/openhab/core/load_path.rb
 - lib/openhab/core/openhab_setup.rb
 - lib/openhab/core/osgi.rb
+- lib/openhab/core/script_handling.rb
+- lib/openhab/core/thread_local.rb
 - lib/openhab/dsl/actions.rb
 - lib/openhab/dsl/dsl.rb
 - lib/openhab/dsl/gems.rb
 - lib/openhab/dsl/group.rb
+- lib/openhab/dsl/items/color_item.rb
 - lib/openhab/dsl/items/comparable_item.rb
 - lib/openhab/dsl/items/contact_item.rb
 - lib/openhab/dsl/items/date_time_item.rb
@@ -65,6 +68,7 @@ files:
 - lib/openhab/dsl/items/item_equality.rb
 - lib/openhab/dsl/items/item_registry.rb
 - lib/openhab/dsl/items/items.rb
+- lib/openhab/dsl/items/location_item.rb
 - lib/openhab/dsl/items/metadata.rb
 - lib/openhab/dsl/items/number_item.rb
 - lib/openhab/dsl/items/numeric_item.rb
@@ -105,6 +109,7 @@ files:
 - lib/openhab/dsl/types/comparable_type.rb
 - lib/openhab/dsl/types/date_time_type.rb
 - lib/openhab/dsl/types/decimal_type.rb
+- lib/openhab/dsl/types/hsb_type.rb
 - lib/openhab/dsl/types/increase_decrease_type.rb
 - lib/openhab/dsl/types/next_previous_type.rb
 - lib/openhab/dsl/types/numeric_type.rb
@@ -112,6 +117,7 @@ files:
 - lib/openhab/dsl/types/open_closed_type.rb
 - lib/openhab/dsl/types/percent_type.rb
 - lib/openhab/dsl/types/play_pause_type.rb
+- lib/openhab/dsl/types/point_type.rb
 - lib/openhab/dsl/types/quantity_type.rb
 - lib/openhab/dsl/types/refresh_type.rb
 - lib/openhab/dsl/types/rewind_fastforward_type.rb