openhab-scripting 4.1.4 → 4.5.0

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

@@ -1,94 +1,42 @@
 # frozen_string_literal: true
 
-require 'forwardable'
-require 'java'
-require 'openhab/dsl/items/item_command'
-require 'openhab/dsl/items/item_delegate'
+require_relative 'numeric_item'
 
 module OpenHAB
   module DSL
     module Items
-      #
-      # Delegator to OpenHAB Rollershutter Item
-      #
-      class RollershutterItem < Numeric
-        extend Forwardable
-        extend OpenHAB::DSL::Items::ItemCommand
-        extend OpenHAB::DSL::Items::ItemDelegate
-        include Comparable
+      java_import org.openhab.core.library.items.RollershutterItem
 
-        def_item_delegator :@rollershutter_item
+      # Adds methods to core OpenHAB RollershutterItem type to make it more natural in
+      # Ruby
+      class RollershutterItem < GenericItem
+        include NumericItem
 
-        item_type Java::OrgOpenhabCoreLibraryItems::RollershutterItem
+        alias position state
 
-        #
-        # Creates a new RollershutterItem
-        #
-        # @param [Java::OrgOpenhabCoreLibraryItems::RollershutterItem] rollershutter_item
-        #   The OpenHAB RollershutterItem to delegate to
-        #
-        def initialize(rollershutter_item)
-          logger.trace("Wrapping #{rollershutter_item}")
-          @rollershutter_item = rollershutter_item
+        # @!method up?
+        #   Check if the item state == +UP+
+        #   @return [Boolean]
 
-          item_missing_delegate { @rollershutter_item }
-          item_missing_delegate { position }
+        # @!method down?
+        #   Check if the item state == +DOWN+
+        #   @return [Boolean]
 
-          super()
-        end
+        # @!method up
+        #   Send the +UP+ command to the item
+        #   @return [RollershutterItem] +self+
 
-        #
-        # Returns the rollershutter's position
-        #
-        # @return [Java::OrgOpenhabCoreLibraryTypes::PercentType] the position of the rollershutter
-        #
-        def position
-          state&.as(PercentType)
-        end
+        # @!method down
+        #   Send the +DOWN+ command to the item
+        #   @return [RollershutterItem] +self+
 
-        #
-        # Compare the rollershutter's position against another object
-        #
-        # @param [Object] other object to compare against
-        #
-        # @return [Integer] -1, 0 or 1 depending on the result of the comparison
-        #
-        def <=>(other)
-          return nil unless state?
+        # @!method stop
+        #   Send the +STOP+ command to the item
+        #   @return [RollershutterItem] +self+
 
-          case other
-          when PercentType, Java::OrgOpenhabCoreLibraryTypes::DecimalType then position.compare_to(other)
-          when Numeric then position.int_value <=> other
-          when RollershutterItem then position.compare_to(other.position)
-          when UpDownType then state.as(UpDownType) == other
-          end
-        end
-
-        #
-        # Coerce self into other to enable calculations
-        #
-        # @param [Numeric] other Other numeric to coerce into
-        #
-        # @return [Array<Numeric>] an array of other and self coerced into other's type
-        #
-        def coerce(other)
-          raise ArgumentError, "Cannot coerce to #{other.class}" unless other.is_a? Numeric
-
-          case other
-          when Integer then [other, position&.int_value]
-          when Float then [other, position&.float_value]
-          end
-        end
-
-        #
-        # Define math operations
-        #
-        %i[+ - * / %].each do |operator|
-          define_method(operator) do |other|
-            right, left = coerce(other)
-            left&.send(operator, right)
-          end
-        end
+        # @!method move
+        #   Send the +MOVE+ command to the item
+        #   @return [RollershutterItem] +self+
       end
     end
   end

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

@@ -1,63 +1,36 @@
 # frozen_string_literal: true
 
-require 'bigdecimal'
 require 'forwardable'
-require 'java'
-require 'openhab/dsl/items/item_delegate'
+
+require 'openhab/dsl/items/comparable_item'
 
 module OpenHAB
   module DSL
     module Items
-      #
-      # Delegator to OpenHAB String Item
-      #
-      class StringItem
+      java_import org.openhab.core.library.items.StringItem
+
+      # Adds methods to core OpenHAB StringItem type to make it more natural in
+      # Ruby
+      class StringItem < GenericItem
         extend Forwardable
-        extend OpenHAB::DSL::Items::ItemCommand
         include Comparable
-        extend OpenHAB::DSL::Items::ItemDelegate
+        include ComparableItem
+
+        remove_method :==
 
         # @return [Regex] Regular expression matching blank strings
         BLANK_RE = /\A[[:space:]]*\z/.freeze
         private_constant :BLANK_RE
 
-        def_item_delegator :@string_item
-
-        item_type Java::OrgOpenhabCoreLibraryItems::StringItem
-
-        #
-        # Create a new StringItem
-        #
-        # @param [Java::Org::openhab::core::library::items::StringItem] string_item OpenHAB string item to delegate to
-        #
-        def initialize(string_item)
-          @string_item = string_item
-
-          item_missing_delegate { @string_item }
-          item_missing_delegate { @string_item.state&.to_full_string&.to_s }
-
-          super()
-        end
-
-        #
-        # Convert the StringItem into a String
-        #
-        # @return [String] String representation of the StringItem or
-        #   nil if underlying OpenHAB StringItem does not have a state
-        #
-        def to_str
-          @string_item.state&.to_full_string&.to_s
-        end
-
         #
         # Detect if the string is blank (not set or only whitespace)
         #
         # @return [Boolean] True if string item is not set or contains only whitespace, false otherwise
         #
         def blank?
-          return true unless @string_item.state?
+          return true unless state?
 
-          @string_item.state.to_full_string.to_s.empty? || BLANK_RE.match?(self)
+          state.empty? || BLANK_RE.match?(self)
         end
 
         #
@@ -66,27 +39,12 @@ module OpenHAB
         # @return [Boolean] True if item is not in state UNDEF or NULL and value is not blank
         #
         def truthy?
-          @string_item.state? && blank? == false
+          state? && !blank?
         end
 
-        #
-        # Compare StringItem to supplied object
-        #
-        # @param [Object] other object to compare to
-        #
-        # @return [Integer] -1,0,1 or nil depending on value supplied,
-        #   nil comparison to supplied object is not possible.
-        #
-        def <=>(other)
-          case other
-          when StringItem
-            @string_item.state <=> other.state
-          when String
-            @string_item.state.to_s <=> other
-          else
-            @string_item.state <=> other
-          end
-        end
+        # any method that exists on String gets forwarded to state (which will forward as
+        # necessary)
+        delegate (String.instance_methods - instance_methods) => :state
       end
     end
   end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module DSL
+    #
+    # Patches OpenHAB items
+    #
+    module Items
+      java_import org.openhab.core.library.items.SwitchItem
+
+      # Alias class names for easy is_a? comparisons
+      ::Switch = SwitchItem
+
+      # Adds methods to core OpenHAB SwitchItem type to make it more natural in
+      # Ruby
+      class SwitchItem < GenericItem
+        remove_method :==
+
+        def truthy?
+          on?
+        end
+
+        #
+        # Send a command to invert the state of the switch
+        #
+        # @return [Types::OnOffType] Inverted state
+        #
+        def toggle
+          command(!self)
+        end
+
+        #
+        # Return the inverted state of the switch: +ON+ if the switch is +OFF+,
+        # +UNDEF+ or +NULL+; +OFF+ if the switch is +ON+
+        #
+        # @return [Types::OnOffType] Inverted state
+        #
+        def !
+          return !state if state?
+
+          ON
+        end
+
+        # @!method on?
+        #   Check if the item state == +ON+
+        #   @return [Boolean]
+
+        # @!method off?
+        #   Check if the item state == +OFF+
+        #   @return [Boolean]
+
+        # @!method on
+        #   Send the +ON+ command to the item
+        #   @return [SwitchItem] +self+
+
+        # @!method off
+        #   Send the +OFF+ command to the item
+        #   @return [SwitchItem] +self+
+      end
+    end
+  end
+end

data/lib/openhab/dsl/lazy_array.rb

@@ -2,7 +2,7 @@
 
 module OpenHAB
   module DSL
-    # common base class for array-like collections that have lookup
+    # Common base class for array-like collections that have lookup
     # methods to avoid instantiating the elements if you only use
     # the lookup method
     #
@@ -11,7 +11,7 @@ module OpenHAB
     module LazyArray
       include Enumerable
 
-      # Calls the given block once for each Thing, passing that Thing as a
+      # Calls the given block once for each object, passing that object as a
       # parameter. Returns self.
       #
       # If no block is given, an Enumerator is returned.
@@ -20,20 +20,22 @@ module OpenHAB
         self
       end
 
-      # implicitly convertible to array
+      # Implicitly convertible to array
+      #
+      # @return [Array]
+      #
       def to_ary
         to_a
       end
 
-      # delegate any other methods to the actual array
-      # exclude mutating methods though
+      # Delegate any other methods to the actual array, exclude mutating methods
       def method_missing(method, *args, &block)
         return to_a.send(method, *args, &block) if method[-1] != '!' && Array.instance_methods.include?(method)
 
         super
       end
 
-      # advertise that methods exist that would be delegated to Array
+      # @!visibility private
       def respond_to_missing?(method, include_private = false)
         return true if method[-1] != '!' && Array.instance_methods.include?(method.to_sym)
 

data/lib/openhab/dsl/monkey_patch/events/events.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'openhab/dsl/monkey_patch/events/item_state'
 require 'openhab/dsl/monkey_patch/events/item_event'
+require 'openhab/dsl/monkey_patch/events/item_state'
 require 'openhab/dsl/monkey_patch/events/item_state_changed'
-require 'openhab/dsl/monkey_patch/events/thing_status_info'
 require 'openhab/dsl/monkey_patch/events/item_command'
+require 'openhab/dsl/monkey_patch/events/thing_status_info'

data/lib/openhab/dsl/monkey_patch/events/item_command.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'java'
+require_relative 'item_event'
 
 module OpenHAB
   module DSL
@@ -9,32 +9,75 @@ module OpenHAB
       # Patches OpenHAB events
       #
       module Events
-        java_import Java::OrgOpenhabCoreItemsEvents::ItemCommandEvent
-
-        #
-        # Monkey patch with ruby style accesors
-        #
-        class ItemCommandEvent
-          include Log
+        java_import org.openhab.core.items.events.ItemCommandEvent
 
+        # Adds methods to core OpenHAB ItemCommandEvent to make it more natural in Ruby
+        class ItemCommandEvent < ItemEvent
+          # @return [Type]
           alias command item_command
 
-          #
-          # For every value in the supplied enumeration create a corresponding method mapped to the lowercase
-          # string representation of the enum value For example, an enum with values of STOP and START
-          # would create methods stop? and start? that check if the command is corresponding STOP and START type
-          #
-          # @param [Java::JavaLang::Enum] command_enum Enumeration to create commands for
-          #
-          def self.def_enum_predicates(command_enum)
-            command_enum.values.each do |command| # rubocop:disable Style/HashEachMethods : Java enum does not have each_value
-              command_method = "#{command.to_s.downcase}?"
-              logger.trace("Creating predicate method (#{command_method}) for #{self}")
-              define_method(command_method) do
-                self.command == command
-              end
-            end
-          end
+          # @!method refresh?
+          #   Check if == +REFRESH+
+          #   @return [Boolean]
+
+          # @!method on?
+          #   Check if == +ON+
+          #   @return [Boolean]
+
+          # @!method off?
+          #   Check if == +OFF+
+          #   @return [Boolean]
+
+          # @!method up?
+          #   Check if == +UP+
+          #   @return [Boolean]
+
+          # @!method down?
+          #   Check if == +DOWN+
+          #   @return [Boolean]
+
+          # @!method stop?
+          #   Check if == +STOP+
+          #   @return [Boolean]
+
+          # @!method move?
+          #   Check if == +MOVE+
+          #   @return [Boolean]
+
+          # @!method increase?
+          #   Check if == +INCREASE+
+          #   @return [Boolean]
+
+          # @!method decrease?
+          #   Check if == +DECREASE+
+          #   @return [Boolean]
+
+          # @!method play?
+          #   Check if == +PLAY+
+          #   @return [Boolean]
+
+          # @!method pause?
+          #   Check if == +PAUSE+
+          #   @return [Boolean]
+
+          # @!method rewind?
+          #   Check if == +REWIND+
+          #   @return [Boolean]
+
+          # @!method fast_forward?
+          #   Check if == +FASTFORWARD+
+          #   @return [Boolean]
+
+          # @deprecated
+          # @!parse alias fastforward? fast_forward?
+
+          # @!method next?
+          #   Check if == +NEXT+
+          #   @return [Boolean]
+
+          # @!method previous?
+          #   Check if == +PREVIOUS+
+          #   @return [Boolean]
         end
       end
     end

data/lib/openhab/dsl/monkey_patch/events/item_event.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'java'
-
 module OpenHAB
   module DSL
     module MonkeyPatch
@@ -9,14 +7,16 @@ module OpenHAB
       # Patches OpenHAB events
       #
       module Events
-        java_import Java::OrgOpenhabCoreItemsEvents::ItemEvent
+        java_import org.openhab.core.items.events.ItemEvent
 
         #
-        # MonkeyPatch to add item
+        # Adds methods to core OpenHAB ItemEvent to make it more natural in Ruby
         #
         class ItemEvent
           #
-          # Return a decorated item
+          # The triggering item
+          #
+          # @return [GenericItem]
           #
           def item
             OpenHAB::Core::EntityLookup.lookup_item(item_name)

data/lib/openhab/dsl/monkey_patch/events/item_state.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'java'
+require 'openhab/dsl/types/un_def_type'
 
 module OpenHAB
   module DSL
@@ -9,18 +9,17 @@ module OpenHAB
       # Patches OpenHAB events
       #
       module Events
-        java_import Java::OrgOpenhabCoreItemsEvents::ItemStateEvent
-        java_import Java::OrgOpenhabCoreTypes::UnDefType
+        java_import org.openhab.core.items.events.ItemStateEvent
 
         # Helpers common to ItemStateEvent and ItemStateChangedEvent
-        module ItemStateUnDefTypeHelpers
+        module ItemState
           #
           # Check if the state == UNDEF
           #
           # @return [Boolean] True if the state is UNDEF, false otherwise
           #
           def undef?
-            item_state == UnDefType::UNDEF
+            item_state == UNDEF
           end
 
           #
@@ -28,7 +27,7 @@ module OpenHAB
           #
           # @return [Boolean] True if the state is NULL, false otherwise
           def null?
-            item_state == UnDefType::NULL
+            item_state == NULL
           end
 
           #
@@ -37,13 +36,13 @@ module OpenHAB
           # @return [Boolean] True if state is not UNDEF or NULL
           #
           def state?
-            undef? == false && null? == false
+            !item_state.is_a?(Types::UnDefType)
           end
 
           #
           # Get the item state
           #
-          # @return [State] OpenHAB state if state is not UNDEF or NULL, nil otherwise
+          # @return [Types::PrimitiveState] OpenHAB state if state is not UNDEF or NULL, nil otherwise
           #
           def state
             item_state if state?
@@ -51,10 +50,10 @@ module OpenHAB
         end
 
         #
-        # MonkeyPatch with ruby style accessors
+        # Adds methods to core OpenHAB ItemStateEvent to make it more natural in Ruby
         #
-        class ItemStateEvent
-          include ItemStateUnDefTypeHelpers
+        class ItemStateEvent < ItemEvent
+          include ItemState
         end
       end
     end

data/lib/openhab/dsl/monkey_patch/events/item_state_changed.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'java'
+require 'openhab/dsl/types/un_def_type'
 
 module OpenHAB
   module DSL
@@ -9,14 +9,13 @@ module OpenHAB
       # Patches OpenHAB events
       #
       module Events
-        java_import Java::OrgOpenhabCoreItemsEvents::ItemStateChangedEvent
-        java_import Java::OrgOpenhabCoreTypes::UnDefType
+        java_import org.openhab.core.items.events.ItemStateChangedEvent
 
         #
-        # MonkeyPatch with ruby style accessors
+        # Adds methods to core OpenHAB ItemStateChangedEvent to make it more natural in Ruby
         #
-        class ItemStateChangedEvent
-          include ItemStateUnDefTypeHelpers
+        class ItemStateChangedEvent < ItemEvent
+          include ItemState
 
           #
           # Check if state was == UNDEF
@@ -24,7 +23,7 @@ module OpenHAB
           # @return [Boolean] True if the state is UNDEF, false otherwise
           #
           def was_undef?
-            old_item_state == UnDefType::UNDEF
+            old_item_state == UNDEF
           end
 
           #
@@ -32,7 +31,7 @@ module OpenHAB
           #
           # @return [Boolean] True if the state is NULL, false otherwise
           def was_null?
-            old_item_state == UnDefType::NULL
+            old_item_state == NULL
           end
 
           #
@@ -41,18 +40,18 @@ module OpenHAB
           # @return [Boolean] True if state is not UNDEF or NULL
           #
           def was?
-            was_undef? == false && was_null? == false
+            !old_item_state.is_a?(Types::UnDefType)
           end
 
           #
           # Get the previous item state
           #
-          # @return [State] OpenHAB state if state was not UNDEF or NULL, nil otherwise
+          # @return [Types::Type] OpenHAB state if state was not UNDEF or NULL, nil otherwise
           #
           def was
             old_item_state if was?
           end
-
+          # @deprecated
           alias last was
         end
       end

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

@@ -16,7 +16,7 @@ module OpenHAB
           # @return [Java::JavaTime::Duration] Duration with number of units from self
           #
           %w[millis seconds minutes hours].each do |unit|
-            define_method(unit) { Java::JavaTime::Duration.public_send("of_#{unit}", self) }
+            define_method(unit) { java.time.Duration.public_send("of_#{unit}", self) }
           end
 
           alias second seconds
@@ -37,7 +37,7 @@ module OpenHAB
           # @return [Java::JavaTime::Duration] Duration truncated to an integral number of milliseconds from self
           #
           def millis
-            Java::JavaTime::Duration.of_millis(to_i)
+            java.time.Duration.of_millis(to_i)
           end
 
           #
@@ -74,6 +74,26 @@ module OpenHAB
           alias minute minutes
           alias hour hours
         end
+
+        #
+        # Extend numeric to create quantity object
+        #
+        module NumericExtensions
+          #
+          # Convert Numeric to a QuantityType
+          #
+          # @param [Object] other String or Unit representing an OpenHAB Unit
+          #
+          # @return [Types::QuantityType] +self+ as a {Types::QuantityType} of the supplied Unit
+          #
+          def |(other)
+            other = org.openhab.core.types.util.UnitUtils.parse_unit(other.to_str) if other.respond_to?(:to_str)
+
+            return super unless other.is_a?(javax.measure.Unit)
+
+            QuantityType.new(to_d.to_java, other)
+          end
+        end
       end
     end
   end
@@ -81,3 +101,6 @@ end
 
 Integer.prepend(OpenHAB::DSL::MonkeyPatch::Ruby::IntegerExtensions)
 Float.prepend(OpenHAB::DSL::MonkeyPatch::Ruby::FloatExtensions)
+Numeric.include(OpenHAB::DSL::MonkeyPatch::Ruby::NumericExtensions)
+# Integer already has #|, so we have to prepend it here
+Integer.prepend(OpenHAB::DSL::MonkeyPatch::Ruby::NumericExtensions)

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

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-# Monkey patch ruby
-require 'openhab/dsl/monkey_patch/ruby/range'
 require 'openhab/dsl/monkey_patch/ruby/number'
 require 'openhab/dsl/monkey_patch/ruby/string'
-require 'openhab/dsl/monkey_patch/ruby/time'
 require 'bigdecimal/util'