openhab-scripting 4.1.4 → 4.2.0

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

@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-
-require 'java'
-require 'openhab/dsl/items/item_command'
-require 'forwardable'
-
-module OpenHAB
-  module DSL
-    module MonkeyPatch
-      #
-      # Patches OpenHAB items
-      #
-      module Items
-        java_import Java::OrgOpenhabCoreLibraryItems::DimmerItem
-        java_import Java::OrgOpenhabCoreItems::GenericItem
-
-        #
-        # Alias class for is_a? testing
-        #
-        ::Dimmer = DimmerItem
-
-        #
-        # Monkey Patch DimmerItem
-        #
-        class DimmerItem
-          include Comparable
-          java_import Java::OrgOpenhabCoreLibraryTypes::DecimalType
-          java_import Java::OrgOpenhabCoreLibraryTypes::IncreaseDecreaseType
-
-          extend Forwardable
-          extend OpenHAB::DSL::Items::ItemCommand
-
-          item_type Java::OrgOpenhabCoreLibraryItems::DimmerItem
-
-          def_delegator :state, :to_s
-
-          #
-          # Dim the dimmer
-          #
-          # @param [Integer] amount to dim by
-          #
-          # @return [Integer] level target for dimmer
-          #
-          def dim(amount = 1)
-            [state&.to_big_decimal&.intValue&.-(amount), 0].compact
-                                                           .max
-                                                           .tap { |target| command(target) }
-          end
-
-          #
-          # Brighten the dimmer
-          #
-          # @param [Integer] amount to brighten by
-          #
-          # @return [Integer] level target for dimmer
-          #
-          def brighten(amount = 1)
-            state&.to_big_decimal&.intValue&.+(amount)&.tap { |target| command(target) }
-          end
-
-          #
-          # Compare DimmerItem 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)
-            logger.trace("Comparing #{self} to #{other}")
-            case other
-            when GenericItem, NumberItem then state <=> other.state
-            when DecimalType then state <=> other
-            when Numeric then state.to_big_decimal.to_d <=> other.to_d
-            else compare_to(other)
-            end
-          end
-
-          #
-          # Coerce objects into a DimmerItem
-          #
-          # @param [Object] other object to coerce to a DimmerItem if possible
-          #
-          # @return [Object] Numeric when applicable
-          #
-          def coerce(other)
-            logger.trace("Coercing #{self} as a request from  #{other.class}")
-            case other
-            when Numeric then [other, state.to_big_decimal.to_d]
-            else [other, state]
-            end
-          end
-
-          #
-          # Compare DimmerItem to supplied object.
-          # The == operator needs to be overridden because the parent java object
-          # has .equals which overrides the <=> operator above
-          #
-          # @param [Object] other object to compare to
-          #
-          # @return [Integer] true if the two objects contain the same value, false otherwise
-          #
-          def ==(other)
-            (self <=> other).zero?
-          end
-
-          #
-          # Define math operations
-          #
-          %i[+ - / *].each do |operator|
-            define_method(operator) do |other|
-              right, left = coerce(other)
-              left.send(operator, right)
-            end
-          end
-
-          #
-          # Check if dimmer has a state and state is not zero
-          #
-          # @return [Boolean] True if dimmer is not NULL or UNDEF and value is not 0
-          #
-          def truthy?
-            state? && state != DecimalType::ZERO
-          end
-
-          #
-          # Value of dimmer
-          #
-          # @return [Integer] Value of dimmer or nil if state is UNDEF or NULL
-          #
-          def to_i
-            state&.to_big_decimal&.intValue
-          end
-
-          alias to_int to_i
-        end
-      end
-    end
-  end
-end

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