openhab-scripting 4.1.4 → 4.5.0

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

@@ -1,142 +0,0 @@
-# frozen_string_literal: true
-
-require 'java'
-require 'openhab/log/logger'
-require 'bigdecimal'
-
-# Monkey patch items
-require 'openhab/dsl/monkey_patch/items/metadata'
-require 'openhab/dsl/monkey_patch/items/persistence'
-require 'openhab/dsl/monkey_patch/items/contact_item'
-require 'openhab/dsl/monkey_patch/items/dimmer_item'
-require 'openhab/dsl/monkey_patch/items/switch_item'
-
-module OpenHAB
-  module DSL
-    module MonkeyPatch
-      #
-      # Monkeypatches Items
-      #
-      module Items
-        #
-        # Extensions for Items
-        #
-        module ItemExtensions
-          include OpenHAB::Log
-          java_import Java::OrgOpenhabCoreModelScriptActions::BusEvent
-          java_import Java::OrgOpenhabCoreTypes::UnDefType
-
-          #
-          # Send a command to this item
-          #
-          # @param [Object] command to send to object
-          #
-          #
-          def command(command)
-            command = command.to_java.strip_trailing_zeros.to_plain_string if command.is_a? BigDecimal
-            logger.trace "Sending Command #{command} to #{id}"
-            BusEvent.sendCommand(self, command.to_s)
-          end
-
-          alias << command
-
-          #
-          # Send an update to this item
-          #
-          # @param [Object] update the item
-          #
-          #
-          def update(update)
-            update = update.to_java.strip_trailing_zeros.to_plain_string if update.is_a? BigDecimal
-            logger.trace "Sending Update #{update} to #{id}"
-            BusEvent.postUpdate(self, update.to_s)
-          end
-
-          #
-          # Check if the item state == UNDEF
-          #
-          # @return [Boolean] True if the state is UNDEF, false otherwise
-          #
-          def undef?
-            # Need to explicitly call the super method version because this state will never return UNDEF
-            method(:state).super_method.call == UnDefType::UNDEF
-          end
-
-          #
-          # Check if the item state == NULL
-          #
-          # @return [Boolean] True if the state is NULL, false otherwise
-          def null?
-            # Need to explicitly call the super method version because this state will never return NULL
-            method(:state).super_method.call == UnDefType::NULL
-          end
-
-          #
-          # Check if the item has a state (not UNDEF or NULL)
-          #
-          # @return [Boolean] True if state is not UNDEF or NULL
-          #
-          def state?
-            undef? == false && null? == false
-          end
-
-          #
-          # Get the item state
-          #
-          # @return [State] OpenHAB item state if state is not UNDEF or NULL, nil otherwise
-          #
-          def state
-            super if state?
-          end
-
-          #
-          # Get an ID for the item, using the item label if set, otherwise item name
-          #
-          # @return [String] label if set otherwise name
-          #
-          def id
-            label || name
-          end
-
-          #
-          # Get the string representation of the state of the item
-          #
-          # @return [String] State of the item as a string
-          #
-          def to_s
-            method(:state).super_method.call.to_s # call the super state to include UNDEF/NULL
-          end
-
-          #
-          # Inspect the item
-          #
-          # @return [String] details of the item
-          #
-          def inspect
-            toString
-          end
-
-          #
-          # Return all groups that this item is part of
-          #
-          # @return [Array<Group>] All groups that this item is part of
-          #
-          def groups
-            group_names.map { |name| OpenHAB::DSL::Groups.groups[name] }
-          end
-        end
-
-        java_import Java::OrgOpenhabCoreItems::GenericItem
-
-        #
-        # Monkey patches all OpenHAB items
-        #
-        class GenericItem
-          prepend OpenHAB::DSL::MonkeyPatch::Items::ItemExtensions
-          prepend OpenHAB::DSL::MonkeyPatch::Items::Metadata
-          prepend OpenHAB::DSL::MonkeyPatch::Items::Persistence
-        end
-      end
-    end
-  end
-end

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

@@ -1,328 +0,0 @@
-# frozen_string_literal: true
-
-require 'java'
-require 'delegate'
-require 'pp'
-require 'forwardable'
-require 'openhab/core/osgi'
-require 'openhab/log/logger'
-
-module OpenHAB
-  module DSL
-    module MonkeyPatch
-      module Items
-        #
-        # Metadata extension for Items
-        #
-        module Metadata
-          include OpenHAB::Log
-
-          java_import Java::OrgOpenhabCoreItems::Metadata
-          java_import Java::OrgOpenhabCoreItems::MetadataKey
-
-          #
-          # Provide the interface to access namespace's value and configuration
-          #
-          class MetadataItem < SimpleDelegator
-            extend Forwardable
-
-            def_delegator :@metadata, :value
-
-            def initialize(metadata: nil, key: nil, value: nil, config: nil)
-              @metadata = metadata || Metadata.new(key || MetadataKey.new('', ''), value&.to_s, config)
-              super(to_ruby(@metadata&.configuration))
-            end
-
-            #
-            # Updates the metadata configuration associated with the key
-            #
-            def []=(key, value)
-              configuration = {}.merge(@metadata&.configuration || {}).merge({ key => value })
-              metadata = Metadata.new(@metadata&.uID, @metadata&.value, configuration)
-              NamespaceAccessor.registry.update(metadata) if @metadata&.uID
-            end
-
-            #
-            # Delete the configuration with the given key
-            #
-            # @return [Java::Org::openhab::core::items::Metadata] the old metadata
-            #
-            def delete(key)
-              configuration = {}.merge(@metadata&.configuration || {})
-              configuration.delete(key)
-              metadata = Metadata.new(@metadata&.uID, @metadata&.value, configuration)
-              NamespaceAccessor.registry.update(metadata) if @metadata&.uID
-            end
-
-            #
-            # Set the metadata value
-            #
-            # @return [Java::Org::openhab::core::items::Metadata] the old metadata
-            #
-            def value=(value)
-              metadata = Metadata.new(@metadata&.uID, value&.to_s, @metadata&.configuration)
-              NamespaceAccessor.registry.update(metadata) if @metadata&.uID
-            end
-
-            #
-            # Set the entire configuration to a hash
-            #
-            # @return [Java::Org::openhab::core::items::Metadata] the old metadata
-            #
-            def config=(config)
-              raise ArgumentError, 'Configuration must be a hash' unless config.is_a? Hash
-
-              metadata = Metadata.new(@metadata&.uID, @metadata&.value, config)
-              NamespaceAccessor.registry.update(metadata) if @metadata&.uID
-            end
-            alias configuration= config=
-
-            #
-            # Convert the metadata to an array
-            #
-            # @return [Array[2]] An array of [value, configuration]
-            #
-            def to_a
-              [@metadata&.value, @metadata&.configuration || {}]
-            end
-
-            private
-
-            #
-            # Recursively convert the supplied Hash object into a Ruby Hash and recreate the keys and values
-            #
-            # @param [Hash] Hash to convert
-            #
-            # @return [Hash] The converted hash
-            #
-            def to_ruby_hash(hash)
-              return unless hash.respond_to? :each_with_object
-
-              hash.each_with_object({}) { |(key, value), ruby_hash| ruby_hash[to_ruby(key)] = to_ruby(value) }
-            end
-
-            #
-            # Recursively convert the supplied array to a Ruby array and recreate all String values
-            #
-            # @param [Object] array to convert
-            #
-            # @return [Array] The converted array
-            #
-            def to_ruby_array(array)
-              return unless array.respond_to? :each_with_object
-
-              array.each_with_object([]) { |value, ruby_array| ruby_array << to_ruby(value) }
-            end
-
-            # Convert the given object to Ruby equivalent
-            def to_ruby(value)
-              case value
-              when Hash, Java::JavaUtil::Map then to_ruby_hash(value)
-              when Array, Java::JavaUtil::List then to_ruby_array(value)
-              when String then String.new(value)
-              else value
-              end
-            end
-          end
-
-          #
-          # Provide the interface to access item metadata
-          #
-          class NamespaceAccessor
-            include Enumerable
-
-            def initialize(item_name:)
-              @item_name = item_name
-            end
-
-            #
-            # Return the metadata namespace
-            #
-            # @return [OpenHAB::DSL::MonkeyPatch::Items::MetadataItem], or nil if the namespace doesn't exist
-            #
-            def [](namespace)
-              logger.trace("Getting metadata for item: #{@item_name}, namespace '#{namespace}'")
-              metadata = NamespaceAccessor.registry.get(MetadataKey.new(namespace, @item_name))
-              MetadataItem.new(metadata: metadata) if metadata
-            end
-
-            #
-            # Set the metadata namespace. If the namespace does not exist, it will be created
-            #
-            # @param value [Object] The assigned value can be a OpenHAB::DSL::MonkeyPatch::Items::MetadataItem,
-            # Java::Org::openhab::core::items::Metadata, Array[2] of [value, configuration],
-            # A String to set the value and clear the configuration,
-            # or a Hash to set the configuration and set the value to nil
-            #
-            # @return [OpenHAB::DSL::MonkeyPatch::Items::MetadataItem]
-            #
-            def []=(namespace, value)
-              meta_value, configuration = update_from_value(value)
-
-              key = MetadataKey.new(namespace, @item_name)
-              metadata = Metadata.new(key, meta_value&.to_s, configuration)
-              # registry.get can be omitted, but registry.update will log a warning for nonexistent metadata
-              if NamespaceAccessor.registry.get(key)
-                NamespaceAccessor.registry.update(metadata)
-              else
-                NamespaceAccessor.registry.add(metadata)
-              end
-            end
-
-            #
-            # Implements Hash#dig-like functionaity to metadata
-            #
-            # @param [String] key The first key
-            # @param [Array<String, Symbol>] keys More keys to dig deeper
-            #
-            # @return [OpenHAB::DSL::MonkeyPatch::Items::MetadataItem], or nil if the namespace doesn't exist
-            #
-            def dig(key, *keys)
-              keys.empty? ? self[key]&.value : self[key]&.dig(*keys)
-            end
-
-            #
-            # Enumerates through all the namespaces
-            #
-            def each
-              return unless block_given?
-
-              NamespaceAccessor.registry.getAll.each do |meta|
-                yield meta.uID.namespace, meta.value, meta.configuration if meta.uID.itemName == @item_name
-              end
-            end
-
-            #
-            # Remove all the namespaces
-            #
-            def clear
-              NamespaceAccessor.registry.removeItemMetadata @item_name
-            end
-
-            #
-            # Delete a specific namespace
-            #
-            # @param namespace [String] The namespace to delete
-            #
-            def delete(namespace)
-              NamespaceAccessor.registry.remove(MetadataKey.new(namespace, @item_name))
-            end
-
-            alias delete_all clear
-
-            #
-            # @return [Boolean] True if the given namespace exists, false otherwise
-            #
-            def key?(namespace)
-              !NamespaceAccessor.registry.get(MetadataKey.new(namespace, @item_name)).nil?
-            end
-
-            alias has_key? key?
-            alias include? key?
-
-            #
-            # Merge the given hash with the current metadata. Existing namespace that matches the name
-            # of the new namespace will be overwritten. Others will be added.
-            #
-            def merge!(*others)
-              return self if others.empty?
-
-              others.each do |other|
-                case other
-                when Hash then merge_hash!(other)
-                when self.class then merge_metadata!(other)
-                else raise ArgumentError, "merge only supports Hash, or another item's metadata"
-                end
-              end
-              self
-            end
-
-            #
-            # @return [String] the string representation of all the namespaces with their value and config
-            #
-            def to_s
-              namespaces = []
-              each { |ns, value, config| namespaces << "\"#{ns}\"=>[\"#{value}\",#{config}]" }
-              "{#{namespaces.join(',')}}"
-            end
-
-            #
-            # @return [Java::org::openhab::core::items::MetadataRegistry]
-            #
-            def self.registry
-              @registry ||= OpenHAB::Core::OSGI.service('org.openhab.core.items.MetadataRegistry')
-            end
-
-            private
-
-            #
-            # perform an updated based on the supplied value
-            #
-            # @param [MetadataItem,Metadata,Array,Hash] value to perform update from
-            #
-            # @return [Array<Object,Hash>] Array containing the value and configuration based on the
-            #   the supplied object
-            #
-            def update_from_value(value)
-              case value
-              when MetadataItem then [value.value, value.__getobj__]
-              when Metadata then [value.value, value.configuration]
-              when Array
-                raise ArgumentError, 'Array must contain 2 elements: value, config' if value.length != 2
-
-                value
-              when Hash then [nil, value]
-              else [value, nil]
-              end
-            end
-
-            #
-            # Merge the metadata from the supplied other metadata object
-            #
-            # @param [Hash] other metadata object to merge
-            # @yield [key, current_metadata, new_meta] to process merge
-            #
-            #
-            def merge_metadata!(other)
-              other.each do |key, new_value, new_config|
-                new_meta = new_value, new_config
-                if block_given?
-                  current_meta = self[key]&.to_a
-                  new_meta = yield key, current_meta, new_meta unless current_meta.nil?
-                end
-                self[key] = new_meta
-              end
-            end
-
-            #
-            # Merge a hash into the metadata
-            #
-            # @param [Hash] other to merge into metadata
-            # @yield [key, current_metadata, new_meta] to process merge
-            #
-            #
-            def merge_hash!(other)
-              other.each do |key, new_meta|
-                if block_given?
-                  current_meta = self[key]&.to_a
-                  new_meta = yield key, current_meta, new_meta unless current_meta.nil?
-                end
-                self[key] = new_meta
-              end
-            end
-          end
-
-          #
-          # Accessor to the item's metadata
-          #
-          # @return [NamespaceAccessor] an Enumerable object to access item's namespaces
-          #
-          def meta
-            @meta ||= NamespaceAccessor.new(item_name: name)
-          end
-          alias metadata meta
-        end
-      end
-    end
-  end
-end

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

@@ -1,123 +0,0 @@
-# frozen_string_literal: true
-
-module OpenHAB
-  module DSL
-    module MonkeyPatch
-      module Items
-        #
-        # Persistence extension for Items
-        #
-        module Persistence
-          java_import Java::OrgOpenhabCoreTypesUtil::UnitUtils
-
-          # A wrapper for OpenHAB's HistoricItem that returns the state directly
-          class HistoricState < SimpleDelegator
-            attr_reader :timestamp, :state
-
-            def initialize(state, timestamp)
-              @state = state
-              @timestamp = timestamp
-              super(@state)
-            end
-          end
-
-          # All persistence methods that could return a Quantity
-          QUANTITY_METHODS = %i[average_since
-                                delta_since
-                                deviation_since
-                                sum_since
-                                variance_since].freeze
-
-          # All persistence methods that require a timestamp
-          PERSISTENCE_METHODS = (QUANTITY_METHODS +
-                                %i[changed_since
-                                   evolution_rate
-                                   historic_state
-                                   maximum_since
-                                   minimum_since
-                                   updated_since]).freeze
-
-          %i[persist last_update].each do |method|
-            define_method(method) do |service = nil|
-              service ||= persistence_service
-              PersistenceExtensions.public_send(method, self, service&.to_s)
-            end
-          end
-
-          #
-          # Return the previous state of the item
-          #
-          # @param skip_equal [Boolean] if true, skips equal state values and
-          #        searches the first state not equal the current state
-          # @param service [String] the name of the PersistenceService to use
-          #
-          # @return the previous state or nil if no previous state could be found,
-          #         or if the default persistence service is not configured or
-          #         does not refer to a valid service
-          #
-          def previous_state(service = nil, skip_equal: false)
-            service ||= persistence_service
-            result = PersistenceExtensions.previous_state(self, skip_equal, service&.to_s)
-            HistoricState.new(quantify(result.state), result.timestamp)
-          end
-
-          PERSISTENCE_METHODS.each do |method|
-            define_method(method) do |timestamp, service = nil|
-              service ||= persistence_service
-              result = PersistenceExtensions.public_send(method, self, to_zdt(timestamp), service&.to_s)
-              if result.is_a? Java::OrgOpenhabCorePersistence::HistoricItem
-                return HistoricState.new(quantify(result.state), result.timestamp)
-              end
-
-              QUANTITY_METHODS.include?(method) ? quantify(result) : result
-            end
-          end
-
-          private
-
-          #
-          # Convert timestamp to ZonedDateTime if it's a TemporalAmount
-          #
-          # @param [Object] timestamp to convert
-          #
-          # @return [ZonedDateTime]
-          #
-          def to_zdt(timestamp)
-            if timestamp.is_a? Java::JavaTimeTemporal::TemporalAmount
-              logger.trace("Converting #{timestamp} (#{timestamp.class}) to ZonedDateTime")
-              Java::JavaTime::ZonedDateTime.now.minus(timestamp)
-            else
-              timestamp
-            end
-          end
-
-          #
-          # Convert value to Quantity if it is a DecimalType and a unit is defined
-          #
-          # @param [Object] value The value to convert
-          #
-          # @return [Object] Quantity or the original value
-          #
-          def quantify(value)
-            if value.is_a?(Java::OrgOpenhabCoreLibraryTypes::DecimalType) && state_description&.pattern
-              item_unit = UnitUtils.parse_unit(state_description.pattern)
-              logger.trace("Unitizing #{value} with unit #{item_unit}")
-              Quantity.new(Java::OrgOpenhabCoreLibraryTypes::QuantityType.new(value.to_big_decimal, item_unit))
-            else
-              value
-            end
-          end
-
-          #
-          # Get the specified persistence service from the current thread local variable
-          #
-          # @return [Object] Persistence service name as String or Symbol, or nil if not set
-          #
-          def persistence_service
-            Thread.current.thread_variable_get(:persistence_service)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-require 'java'
-require 'openhab/dsl/items/item_command'
-
-module OpenHAB
-  module DSL
-    module MonkeyPatch
-      #
-      # Patches OpenHAB items
-      #
-      module Items
-        java_import Java::OrgOpenhabCoreLibraryItems::SwitchItem
-
-        # Alias class names for easy is_a? comparisons
-        ::Switch = SwitchItem
-
-        #
-        # Monkeypatching SwitchItem to add Ruby Support methods
-        #
-        class SwitchItem
-          extend OpenHAB::DSL::Items::ItemCommand
-
-          java_import Java::OrgOpenhabCoreLibraryTypes::OnOffType
-
-          item_type Java::OrgOpenhabCoreLibraryItems::SwitchItem
-
-          alias truthy? on?
-
-          #
-          # Send a command to invert the state of the switch
-          #
-          # @return [OnOffType] Inverted state
-          #
-          def toggle
-            self << !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 [OnOffType] Inverted state
-          #
-          def !
-            return !state if state?
-
-            OnOffType::ON
-          end
-
-          #
-          # Check for equality against supplied object
-          #
-          # @param [Object] other object to compare to
-          #
-          # @return [Boolean] True if other is a OnOffType and other equals state for this switch item,
-          #   otherwise result from super
-          #
-          def ==(other)
-            other = other.get_state_as(OnOffType) if other.respond_to?(:get_state_as)
-
-            if other.is_a? OnOffType
-              state? && state == other
-            else
-              super
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require 'java'
-
-# Monkey patch range to support case equality of OpenHab "Numeric" Objects
-
-module OpenHAB
-  module DSL
-    #
-    # MonkeyPatch both Ruby and OpenHAB Objects to support DSL
-    #
-    module MonkeyPatch
-      #
-      # MonkeyPatch ruby object to support DSL
-      #
-      module Ruby
-        #
-        # Extensions for Range Class to support DimmerItems
-        #
-        module RangeExtensions
-          java_import Java::OrgOpenhabCoreLibraryItems::DimmerItem
-
-          #
-          # Override range === method to support DimmerItems
-          #
-          # @param [Object] other object to compare for case equals
-          #
-          # @return [Boolean] if other is DimmerItem and state is covered by range,
-          #   result from parent Range class if not DimmerItem
-          #
-          def ===(other)
-            return super unless other.is_a? DimmerItem
-
-            cover? other.state.to_i
-          end
-        end
-      end
-    end
-  end
-end
-
-#
-# Prepend Range class with RangeExtensions
-#
-class Range
-  prepend OpenHAB::DSL::MonkeyPatch::Ruby::RangeExtensions
-end