openhab-scripting 4.2.0 → 4.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ebe32d36d3366345d28b81bc71d9cd315d1d84feb4a4f1745c882209b1fdbe2
-  data.tar.gz: 95331e97286e86bc993eb979531c5e3f80bc203e752e97aa9f3a60698fd56274
+  metadata.gz: a9ccae52c29da91b7fadc2ac7ba2459e9870a257396849535458497ba48601e5
+  data.tar.gz: 0015aca73a5c79082adefb486afcbb545e324c0695d492e15397d2e0d691a204
 SHA512:
-  metadata.gz: e406fa7d011a733376bb5977293f44d20b893f1f990486f342c541f8d287c453736b75007ba586bfc5e6801638ac71bc6d294ad1b4a436a83247bee157150eb0
-  data.tar.gz: d4fad57e6ad4f71a969b8f8c6791c4240854a74800647a4bed770123221eb2491c251c2a28bcbcd1649225d348aadd91b0efc188adba16a56aa7115620224028
+  metadata.gz: 2db7c0a6f4182d3145871ab6936aa92d5acbe2a6d29e79f793a464d4fbb9514555021d9f0b103130ed99b04c9e149a414ea96df8f134f7db2fb71bade3824168
+  data.tar.gz: da447a4315a8d177db5fc6e476dd30ba93a071f06c6dc612a361f9d12a8539932f8a1659bdd919d8cdf61be2da759f720020d57fe399eaa1a2533bf5e1f56203

data/lib/openhab/dsl/actions.rb

@@ -9,7 +9,6 @@ module OpenHAB
     # Module to import and streamline access to OpenHAB actions
     #
     module Actions
-      java_import org.openhab.core.library.types.PercentType
       include OpenHAB::Log
 
       OpenHAB::Core::OSGI.services('org.openhab.core.model.script.engine.action.ActionService')&.each do |service|
@@ -83,7 +82,7 @@ module OpenHAB
       # @return [void]
       #
       def say(text, voice: nil, sink: nil, volume: nil)
-        volume = PercentType.new(volume&.to_i) unless volume.is_a?(PercentType) || volume.nil?
+        volume = Types::PercentType.new(volume) unless volume.is_a?(Types::PercentType) || volume.nil?
         Voice.say text, voice, sink, volume
       end
 
@@ -97,7 +96,7 @@ module OpenHAB
       # @return [void]
       #
       def play_sound(filename, sink: nil, volume: nil)
-        volume = PercentType.new(volume&.to_i) unless volume.is_a?(PercentType) || volume.nil?
+        volume = Types::PercentType.new(volume) unless volume.is_a?(Types::PercentType) || volume.nil?
         Audio.playSound sink, filename, volume
       end
     end

data/lib/openhab/dsl/dsl.rb

@@ -10,6 +10,7 @@ require 'openhab/dsl/monkey_patch/ruby/ruby'
 require 'openhab/dsl/monkey_patch/events/events'
 require 'openhab/dsl/monkey_patch/actions/actions'
 require 'openhab/dsl/rules/rule'
+require 'openhab/dsl/rules/terse'
 require 'openhab/dsl/actions'
 require 'openhab/dsl/timers'
 require 'openhab/dsl/group'
@@ -34,6 +35,7 @@ module OpenHAB
       base.send :include, OpenHAB::DSL::Items
       base.send :include, OpenHAB::DSL::Persistence
       base.send :include, OpenHAB::DSL::Rules
+      base.send :include, OpenHAB::DSL::Rules::Terse
       base.send :include, OpenHAB::DSL::States
       base.send :include, OpenHAB::DSL::Things
       base.send :include, OpenHAB::DSL::Timers

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative 'generic_item'
+
+module OpenHAB
+  module DSL
+    module Items
+      # Functionality to implement +ensure+/+ensure_states+
+      module Ensure
+        # Contains the global +ensure_states+ method
+        module EnsureStates
+          # Global method that takes a block and for the duration of the block
+          # all commands sent will check if the item is in the command's state
+          # before sending the command.
+          #
+          # @example Turn on several switches only if they're not already on
+          #   ensure_states do
+          #     Switch1.on
+          #     Switch2.on
+          #   end
+          def ensure_states
+            old = Thread.current[:ensure_states]
+            Thread.current[:ensure_states] = true
+            yield
+          ensure
+            Thread.current[:ensure_states] = old
+          end
+          module_function :ensure_states
+        end
+
+        # Contains the +ensure+ method mixed into {GenericItem} and {GroupItem::GroupMembers}
+        module Ensurable
+          # Fluent method call that you can chain commands on to, that will
+          # then automatically ensure that the item is not in the command's
+          # state before sending the command.
+          #
+          # @example Turn switch on only if it's not on
+          #   MySwitch.ensure.on
+          # @example Turn on all switches in a group that aren't already on
+          #   MySwitchGroup.members.ensure.on
+          def ensure
+            GenericItemDelegate.new(self)
+          end
+        end
+
+        # Extensions for {Items::GenericItem} to implement {Ensure}'s
+        # functionality
+        module GenericItem
+          include Ensurable
+
+          # If +ensure_states+ is active (by block or chained method), then
+          # check if this item is in the command's state before actually
+          # sending the command
+          def command(command)
+            return super unless Thread.current[:ensure_states]
+            return if command == state
+
+            super
+          end
+          alias << command
+        end
+
+        # "anonymous" class that wraps any method call in +ensure_states+
+        # before forwarding to the wrapped object
+        # @!visibility private
+        class GenericItemDelegate
+          def initialize(item)
+            @item = item
+          end
+
+          # activate +ensure_states+ before forwarding to the wrapped object
+          def method_missing(method, *args, &block)
+            return super unless @item.respond_to?(method)
+
+            ensure_states do
+              @item.__send__(method, *args, &block)
+            end
+          end
+
+          # .
+          def respond_to_missing?(method, include_private = false)
+            @item.respond_to?(method, include_private) || super
+          end
+        end
+      end
+
+      GenericItem.prepend(Ensure::GenericItem)
+      GroupItem::GroupMembers.include(Ensure::Ensurable)
+    end
+  end
+end
+
+Object.include OpenHAB::DSL::Items::Ensure::EnsureStates

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

@@ -3,6 +3,8 @@
 require 'openhab/dsl/items/metadata'
 require 'openhab/dsl/items/persistence'
 
+require_relative 'item_equality'
+
 module OpenHAB
   module DSL
     module Items
@@ -12,6 +14,8 @@ module OpenHAB
       # Ruby
       class GenericItem
         include Log
+        include ItemEquality
+
         prepend Metadata
         prepend Persistence
 
@@ -135,33 +139,6 @@ module OpenHAB
           other.instance_of?(self.class) && hash == other.hash
         end
 
-        #
-        # Check equality, with type conversions
-        #
-        # @param [GenericItem, Types::Type, Object] other object to
-        #   compare to
-        #
-        #   If this item is +NULL+ or +UNDEF+, and +other+ is nil, they are
-        #   considered equal
-        #
-        #   If this item is +NULL+ or +UNDEF+, and other is a {GenericItem}, they
-        #   are only considered equal if the other item is in the exact same
-        #   state (i.e. +NULL+ != +UNDEF+)
-        #
-        #   Otherwise, the state of this item is compared with +other+
-        #
-        # @return [Boolean]
-        #
-        def ==(other)
-          logger.trace("(#{self.class}) #{self} == #{other} (#{other.class})")
-          return true if equal?(other) || eql?(other)
-          return true if !state? && other.nil?
-
-          return raw_state == other.raw_state if other.is_a?(GenericItem)
-
-          state == other
-        end
-
         # @!method null?
         #   Check if the item state == +NULL+
         #   @return [Boolean]

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

@@ -31,6 +31,74 @@ module OpenHAB
           def to_a
             group.get_members.to_a
           end
+
+          # Send a command to each member of the group
+          #
+          # @return [GroupMembers] +self+
+          def command(command)
+            each { |item| item << command }
+          end
+          alias << command
+
+          # @!method refresh
+          #   Send the +REFRESH+ command to each member of the group
+          #   @return [GroupMembers] +self+
+
+          # @!method on
+          #   Send the +ON+ command to each member of the group
+          #   @return [GroupMembers] +self+
+
+          # @!method off
+          #   Send the +OFF+ command to each member of the group
+          #   @return [GroupMembers] +self+
+
+          # @!method up
+          #   Send the +UP+ command to each member of the group
+          #   @return [GroupMembers] +self+
+
+          # @!method down
+          #   Send the +DOWN+ command to each member of the group
+          #   @return [GroupMembers] +self+
+
+          # @!method stop
+          #   Send the +STOP+ command to each member of the group
+          #   @return [GroupMembers] +self+
+
+          # @!method move
+          #   Send the +MOVE+ command to each member of the group
+          #   @return [GroupMembers] +self+
+
+          # @!method increase
+          #   Send the +INCREASE+ command to each member of the group
+          #   @return [GroupMembers] +self+
+
+          # @!method desrease
+          #   Send the +DECREASE+ command to each member of the group
+          #   @return [GroupMembers] +self+
+
+          # @!method play
+          #   Send the +PLAY+ command to each member of the group
+          #   @return [GroupMembers] +self+
+
+          # @!method pause
+          #   Send the +PAUSE+ command to each member of the group
+          #   @return [GroupMembers] +self+
+
+          # @!method rewind
+          #   Send the +REWIND+ command to each member of the group
+          #   @return [GroupMembers] +self+
+
+          # @!method fast_forward
+          #   Send the +FASTFORWARD+ command to each member of the group
+          #   @return [GroupMembers] +self+
+
+          # @!method next
+          #   Send the +NEXT+ command to each member of the group
+          #   @return [GroupMembers] +self+
+
+          # @!method previous
+          #   Send the +PREVIOUS+ command to each member of the group
+          #   @return [GroupMembers] +self+
         end
 
         include Enumerable

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module DSL
+    module Items
+      # Shared method for checking item equality by delegating to state
+      module ItemEquality
+        # Check equality, with type conversions
+        #
+        # @param [GenericItem, Types::Type, Object] other object to
+        #   compare to
+        #
+        #   If this item is +NULL+ or +UNDEF+, and +other+ is nil, they are
+        #   considered equal
+        #
+        #   If this item is +NULL+ or +UNDEF+, and other is a {GenericItem}, they
+        #   are only considered equal if the other item is in the exact same
+        #   state (i.e. +NULL+ != +UNDEF+)
+        #
+        #   Otherwise, the state of this item is compared with +other+
+        #
+        # @return [Boolean]
+        #
+        def ==(other)
+          logger.trace("(#{self.class}) #{self} == #{other} (#{other.class})")
+          return true if equal?(other) || eql?(other)
+          return true if !state? && other.nil?
+
+          return raw_state == other.raw_state if other.is_a?(GenericItem)
+
+          state == other
+        end
+      end
+    end
+  end
+end

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

@@ -10,14 +10,18 @@ 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'
 require_relative 'string_item'
 
+require_relative 'ensure'
+
 module OpenHAB
   module DSL
     # Contains all OpenHAB *Item classes, as well as associated support
@@ -51,7 +55,7 @@ module OpenHAB
 
         # defined methods for commanding an item to one of the Enum states
         # as well as predicates for if an ItemCommandEvent is one of those commands
-        def def_command_methods(klass) # rubocop:disable Metrics/MethodLength method has single purpose
+        def def_command_methods(klass) # rubocop:disable Metrics method has single purpose
           values_for_enums(klass.ACCEPTED_COMMAND_TYPES).each do |value|
             command = Types::COMMAND_ALIASES[value.to_s]
             next if klass.instance_methods.include?(command)
@@ -63,6 +67,13 @@ module OpenHAB
               end                  # end
             RUBY
 
+            OpenHAB::Core.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}")
             MonkeyPatch::Events::ItemCommandEvent.class_eval <<~RUBY, __FILE__, __LINE__ + 1
               def #{command}?        # def 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

@@ -2,7 +2,8 @@
 
 require 'forwardable'
 
-require 'openhab/dsl/items/comparable_item'
+require_relative 'comparable_item'
+require_relative 'item_equality'
 
 module OpenHAB
   module DSL
@@ -15,6 +16,7 @@ module OpenHAB
 
         # apply meta-programming methods to including class
         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
           # remove the JRuby default == so that we can inherit the Ruby method

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module DSL
+    module Rules
+      # Module containing terse rule stubs
+      module Terse
+        %i[changed channel cron every updated received_command].each do |trigger|
+          class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+            def #{trigger}(*args, name: nil, **kwargs, &block)                   # def changed(*args, name: nil, **kwargs, &block)
+              # if no name is given, just default to the name of the rules file  #   # if no name is given, just default to the name of the rules file
+              name ||= File.basename(caller_locations.last.path)                 #   name ||= File.basename(caller_locations.last.path)
+              rule name do                                                       #   rule name do
+                #{trigger}(*args, **kwargs)                                      #     changed(*args, **kwargs)
+                run(&block)                                                      #     run(&block)
+              end                                                                #   end
+            end                                                                  # end
+            module_function #{trigger.inspect}                                   # module_function :changed
+          RUBY
+        end
+      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

@@ -4,12 +4,14 @@ 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'

data/lib/openhab/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openhab-scripting
 version: !ruby/object:Gem::Version
-  version: 4.2.0
+  version: 4.6.0
 platform: ruby
 authors:
 - Brian O'Connell
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-10-18 00:00:00.000000000 Z
+date: 2021-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -54,15 +54,19 @@ files:
 - 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
 - lib/openhab/dsl/items/dimmer_item.rb
+- lib/openhab/dsl/items/ensure.rb
 - lib/openhab/dsl/items/generic_item.rb
 - lib/openhab/dsl/items/group_item.rb
 - lib/openhab/dsl/items/image_item.rb
+- 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
@@ -89,6 +93,7 @@ files:
 - lib/openhab/dsl/rules/property.rb
 - lib/openhab/dsl/rules/rule.rb
 - lib/openhab/dsl/rules/rule_config.rb
+- lib/openhab/dsl/rules/terse.rb
 - lib/openhab/dsl/rules/triggers/changed.rb
 - lib/openhab/dsl/rules/triggers/channel.rb
 - lib/openhab/dsl/rules/triggers/command.rb
@@ -102,6 +107,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
@@ -109,6 +115,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