openhab-scripting 4.1.4 → 4.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f3ac7afca9a32afdb3e8f52bf8b522919d0b6750a537f4e68808fd7d08eb57b
-  data.tar.gz: e45f368adf72623ea4a9652d9e88b2af06afd9bfc146ae8e308600513be36607
+  metadata.gz: 13732b675b80ad3a92e2346e56da3e7d63b6a4845f8409c5a545d1b5006ab999
+  data.tar.gz: a5b9d54c25a47857256805d849344cfde4602ad23408228cc595bfc574a04587
 SHA512:
-  metadata.gz: 784d720a2b034f87f4d811c504ddf2718bf9340540f1f347e0d5de957a133be542b9dcc072df508662a280978e8e21ee3c188504d7b6ed63ea5a78cef2dc4080
-  data.tar.gz: bb1a34c08c83a46064d529be1ee3082147c441bc1fbe69f0fa3fff7536733fe26ec471d9912b88ba39cd22837649bf81516d95a12b70e59dab59e1592c66668b
+  metadata.gz: 9d8715ab0e0e84315b02a67aeb28f47ebcddb8b58ea5ea1043b53ef329f5f5017329fdae23961530cd1f0ac184e38acf8ad11fd9b1a7a41f77f486cf3d53f01c
+  data.tar.gz: 15a9babdc9a9d7179dda57fcad46356175c25933f534cc4ed1dad9566a56bdde08677b6ef0224c2761fdeb1dd9253f4d6a50cec5a5804bd703b6c843e438a66b

data/lib/openhab/core/entity_lookup.rb

@@ -3,13 +3,6 @@
 require 'pp'
 require 'java'
 require 'set'
-require 'openhab/dsl/group'
-require 'openhab/log/logger'
-require 'openhab/dsl/items/number_item'
-require 'openhab/dsl/items/string_item'
-require 'openhab/dsl/items/datetime_item'
-require 'openhab/dsl/items/rollershutter_item'
-require 'openhab/dsl/items/group_item'
 
 # Automation lookup and injection of OpenHab entities
 
@@ -68,52 +61,6 @@ module OpenHAB
         lookup_item(name) || lookup_thing(name)
       end
 
-      #
-      # Decorate items with Ruby wrappers
-      #
-      # @param [Array] items Array of items to decorate
-      #
-      # @return [Array] Array of decorated items
-      #
-      def self.decorate_items(*items)
-        items.flatten.map { |item| decorate_item(item) }
-      end
-
-      #
-      # Decorate item with Ruby wrappers
-      #
-      # @param [Object] item the item object to decorate
-      #
-      # @return [Object] the ruby wrapper for the item
-      #
-      # rubocop: disable Metrics/MethodLength
-      # rubocop: disable Metrics/CyclomaticComplexity
-      # Disabled line length and branch size - case dispatch pattern
-      def self.decorate_item(item)
-        logger.trace("Decorating #{item.class}")
-        case item
-        when Java::OrgOpenhabCoreItems::GroupItem
-          OpenHAB::DSL::Items::GroupItem.new(item)
-        when Java::OrgOpenhabCoreLibraryItems::NumberItem
-          OpenHAB::DSL::Items::NumberItem.new(item)
-        when Java::OrgOpenhabCoreLibraryItems::StringItem
-          OpenHAB::DSL::Items::StringItem.new(item)
-        when Java::OrgOpenhabCoreLibraryItems::DateTimeItem
-          OpenHAB::DSL::Items::DateTimeItem.new(item)
-        when Java::OrgOpenhabCoreLibraryItems::RollershutterItem
-          OpenHAB::DSL::Items::RollershutterItem.new(item)
-        when Java::OrgOpenhabCoreLibraryItems::PlayerItem
-          OpenHAB::DSL::Items::PlayerItem.new(item)
-        when Java::OrgOpenhabCoreLibraryItems::ImageItem
-          OpenHAB::DSL::Items::ImageItem.new(item)
-        else
-          logger.trace("Returning undecorated item #{item.class}")
-          item
-        end
-      end
-      # rubocop: enable Metrics/MethodLength
-      # rubocop: enable Metrics/CyclomaticComplexity
-
       #
       # Looks up a Thing in the OpenHAB registry replacing '_' with ':'
       #
@@ -145,10 +92,7 @@ module OpenHAB
       def self.lookup_item(name)
         logger.trace("Looking up item(#{name})")
         name = name.to_s if name.is_a? Symbol
-        # rubocop: disable Style/GlobalVars
-        item = $ir.get(name)
-        # rubocop: enable Style/GlobalVars
-        decorate_item(item)
+        $ir.get(name) # rubocop: disable Style/GlobalVars
       end
     end
   end

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

@@ -1,29 +1,24 @@
 # frozen_string_literal: true
 
-require 'java'
 require 'openhab/log/logger'
-require 'openhab/dsl/monkey_patch/events/events'
+
+# the order of these is important
+require 'openhab/dsl/types/types'
+require 'openhab/dsl/items/items'
 require 'openhab/dsl/monkey_patch/ruby/ruby'
-require 'openhab/dsl/monkey_patch/items/items'
-require 'openhab/dsl/monkey_patch/types/types'
+
+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'
 require 'openhab/dsl/things'
-require 'openhab/dsl/items/items'
-require 'openhab/dsl/items/datetime_item'
-require 'openhab/dsl/items/image_item'
-require 'openhab/dsl/items/number_item'
-require 'openhab/dsl/items/player_item'
-require 'openhab/dsl/items/group_item'
 require 'openhab/dsl/time_of_day'
 require 'openhab/dsl/gems'
 require 'openhab/dsl/persistence'
 require 'openhab/dsl/units'
-require 'openhab/dsl/types/datetime'
-require 'openhab/dsl/types/quantity'
 require 'openhab/dsl/states'
 
 module OpenHAB
@@ -40,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/group.rb

@@ -1,10 +1,7 @@
 # frozen_string_literal: true
 
-require 'java'
 require 'singleton'
 
-require 'openhab/core/entity_lookup'
-require 'openhab/dsl/items/group_item'
 require 'openhab/dsl/lazy_array'
 
 module OpenHAB
@@ -35,8 +32,7 @@ module OpenHAB
 
         # explicit conversion to array
         def to_a
-          items = $ir.items.grep(org.openhab.core.items.GroupItem) # rubocop:disable Style/GlobalVars
-          Core::EntityLookup.decorate_items(items)
+          $ir.items.grep(org.openhab.core.items.GroupItem) # rubocop:disable Style/GlobalVars
         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/comparable_item.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module DSL
+    module Items
+      # Mixin for implementing the comparison operator for Item types that
+      # support it
+      module ComparableItem
+        #
+        # Comparison
+        #
+        # @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 [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 we're NULL or UNDEF, implement special logic
+          unless state?
+            # if comparing to nil, consider ourselves equal
+            return 0 if other.nil?
+            # if the other object is an Item, only consider equal if we're
+            # in the same _kind_ of UnDefType state
+            return raw_state == other.raw_state if other.is_a?(GenericItem) && !other.state?
+
+            # otherwise, it's a non-nil thing comparing to nil, which is undefined
+            return nil
+          end
+
+          # delegate to how the state compares to the other object
+          state <=> other
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module DSL
+    #
+    # Patches OpenHAB items
+    #
+    module Items
+      java_import org.openhab.core.library.items.ContactItem
+
+      # Alias class for ContactItem
+      ::Contact = ContactItem
+
+      # Adds methods to core OpenHAB ContactItem type to make it more natural
+      # in Ruby
+      class ContactItem < GenericItem
+        remove_method :==
+
+        #
+        # Return the inverted state of the contact: +CLOSED+ if the contact is
+        # +OPEN+, +UNDEF+ or +NULL+; +OPEN+ if the contact is +CLOSED+
+        #
+        # @return [Types::OpenClosedType] Inverted state
+        #
+        def !
+          return !state if state?
+
+          CLOSED
+        end
+
+        # @!method open?
+        #   Check if the item state == +OPEN+
+        #   @return [Boolean]
+
+        # @!method closed?
+        #   Check if the item state == +CLOSED+
+        #   @return [Boolean]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'time'
+
+require 'openhab/dsl/items/comparable_item'
+
+module OpenHAB
+  module DSL
+    module Items
+      java_import org.openhab.core.library.items.DateTimeItem
+
+      # Adds methods to core OpenHAB DateTimeItem type to make it more natural
+      # in Ruby
+      class DateTimeItem < GenericItem
+        extend Forwardable
+        include Comparable
+        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 DateTimeType
+        #
+        # @param [Types::DateTimeType, Time] other object to coerce to a
+        #   DateTimeType
+        #
+        # @return [[Types::DateTimeType, Types::DateTimeType]]
+        #
+        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::DateTimeType) || other.respond_to?(:to_time)
+
+          raise TypeError, "can't convert #{other.class} into #{self.class}"
+        end
+
+        # any method that exists on DateTimeType, Java's ZonedDateTime, or
+        # Ruby's Time class gets forwarded to state (which will forward as
+        # necessary)
+        delegate ((Types::DateTimeType.instance_methods +
+          java.time.ZonedDateTime.instance_methods +
+          Time.instance_methods) - instance_methods) => :state
+
+        # Time types need formatted as ISO8601
+        # @!visibility private
+        def format_type(command)
+          return command.iso8601 if command.respond_to?(:iso8601)
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'openhab/dsl/time_of_day'
+
+require_relative 'numeric_item'
+
+module OpenHAB
+  module DSL
+    #
+    # Patches OpenHAB items
+    #
+    module Items
+      java_import org.openhab.core.library.items.DimmerItem
+
+      # Alias class
+      ::Dimmer = DimmerItem
+
+      # Adds methods to core OpenHAB DimmerItem type to make it more natural in
+      # Ruby
+      class DimmerItem < SwitchItem
+        include NumericItem
+
+        #
+        # Dim the dimmer
+        #
+        # @param [Integer] amount to dim by
+        #
+        # @return [Integer] level target for dimmer
+        #
+        def dim(amount = 1)
+          target = [state&.-(amount), 0].compact.max
+          command(target)
+          target
+        end
+
+        #
+        # Brighten the dimmer
+        #
+        # @param [Integer] amount to brighten by
+        #
+        # @return [Integer] level target for dimmer
+        #
+        def brighten(amount = 1)
+          target = [state&.+(amount), 100].compact.min
+          command(target)
+          target
+        end
+
+        # @!method increase
+        #   Send the +INCREASE+ command to the item
+        #   @return [DimmerItem] +self+
+
+        # @!method decrease
+        #   Send the +DECREASE+ command to the item
+        #   @return [DimmerItem] +self+
+      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