openhab-scripting 4.1.4 → 4.5.0

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

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require 'openhab/dsl/items/metadata'
+require 'openhab/dsl/items/persistence'
+
+require_relative 'item_equality'
+
+module OpenHAB
+  module DSL
+    module Items
+      java_import org.openhab.core.items.GenericItem
+
+      # Adds methods to core OpenHAB DimmerItem type to make it more natural in
+      # Ruby
+      class GenericItem
+        include Log
+        include ItemEquality
+
+        prepend Metadata
+        prepend Persistence
+
+        # rubocop:disable Naming/MethodName these mimic Java fields, which are
+        # actually methods
+        class << self
+          # manually define this, since the Java side doesn't
+          # @!visibility private
+          def ACCEPTED_COMMAND_TYPES
+            [org.openhab.core.types.RefreshType.java_class].freeze
+          end
+
+          # manually define this, since the Java side doesn't
+          # @!visibility private
+          def ACCEPTED_DATA_TYPES
+            [org.openhab.core.types.UnDefType.java_class].freeze
+          end
+        end
+        # rubocop:enable Naming/MethodName
+
+        alias hash hash_code
+
+        # Get the raw item state.
+        #
+        # The state of the item, including possibly +NULL+ or +UNDEF+
+        #
+        # @return [Types::Type]
+        #
+        alias raw_state state
+
+        remove_method(:==)
+
+        #
+        # Send a command to this item
+        #
+        # @param [Types::Type] command to send to object
+        #
+        #
+        def command(command)
+          command = format_type_pre(command)
+          logger.trace "Sending Command #{command} to #{id}"
+          org.openhab.core.model.script.actions.BusEvent.sendCommand(self, command)
+          self
+        end
+        alias << command
+
+        #
+        # Send an update to this item
+        #
+        # @param [Types::Type] update the item
+        #
+        #
+        def update(update)
+          update = format_type_pre(update)
+          logger.trace "Sending Update #{update} to #{id}"
+          org.openhab.core.model.script.actions.BusEvent.postUpdate(self, update)
+          self
+        end
+
+        #
+        # Check if the item has a state (not +UNDEF+ or +NULL+)
+        #
+        # @return [Boolean]
+        #
+        def state?
+          !raw_state.is_a?(Types::UnDefType)
+        end
+
+        #
+        # Get the item state
+        #
+        # @return [Types::Type, nil]
+        #   OpenHAB item state if state is not +UNDEF+ or +NULL+, nil otherwise
+        #
+        def state
+          raw_state 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
+          raw_state.to_s # call the super state to include UNDEF/NULL
+        end
+
+        #
+        # Inspect the item
+        #
+        # @return [String] details of the item
+        #
+        def inspect
+          to_string
+        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| Groups.groups[name] }
+        end
+
+        #
+        # Check equality without type conversion
+        #
+        # @return [Boolean] if the same Item is represented, without checking
+        #   state
+        def eql?(other)
+          other.instance_of?(self.class) && hash == other.hash
+        end
+
+        # @!method null?
+        #   Check if the item state == +NULL+
+        #   @return [Boolean]
+
+        # @!method undef?
+        #   Check if the item state == +UNDEF+
+        #   @return [Boolean]
+
+        # @!method refresh
+        #   Send the +REFRESH+ command to the item
+        #   @return [GenericItem] +self+
+
+        # formats a {Types::Type} to send to the event bus
+        # @!visibility private
+        def format_type(command)
+          # actual Type types can be sent directly without conversion
+          return command if command.is_a?(Types::Type)
+
+          command.to_s
+        end
+
+        private
+
+        # convert items to their state before formatting, so that subclasses
+        # only have to deal with Types
+        def format_type_pre(command)
+          command = command.state if command.is_a?(GenericItem)
+          format_type(command)
+        end
+      end
+    end
+  end
+end

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

@@ -1,81 +1,121 @@
 # frozen_string_literal: true
 
-require 'delegate'
-require 'forwardable'
-require 'java'
-
-require 'openhab/core/entity_lookup'
-require 'openhab/dsl/items/item_command'
-require 'openhab/dsl/items/item_delegate'
+require_relative 'comparable_item'
 require 'openhab/dsl/lazy_array'
 
 module OpenHAB
   module DSL
     module Items
-      #
-      # Class for indicating to triggers that a group trigger should be used
-      #
-      class GroupMembers
-        include LazyArray
-
-        attr_reader :group
+      java_import org.openhab.core.items.GroupItem
 
+      # Adds methods to core OpenHAB GroupItem type to make it more natural in
+      # Ruby
+      class GroupItem < GenericItem
         #
-        # Create a new GroupMembers instance from a GroupItem
+        # Class for indicating to triggers that a group trigger should be used
         #
-        # @param [GroupItem] group_item GroupItem to use as trigger
-        #
-        def initialize(group_item)
-          @group = group_item
-        end
+        class GroupMembers
+          include LazyArray
 
-        # explicit conversion to array
-        def to_a
-          OpenHAB::Core::EntityLookup.decorate_items(group.members.to_a)
-        end
-      end
+          # @return [GroupItem]
+          attr_reader :group
 
-      #
-      # Delegator to OpenHAB Group Item
-      #
-      class GroupItem
-        extend OpenHAB::DSL::Items::ItemCommand
-        extend OpenHAB::DSL::Items::ItemDelegate
-        include Enumerable
-        include Comparable
+          # @!visibility private
+          def initialize(group_item)
+            @group = group_item
+          end
 
-        def_item_delegator :@group_item
+          # Explicit conversion to Array
+          #
+          # @return [Array]
+          def to_a
+            group.get_members.to_a
+          end
 
-        #
-        # @return [Hash] A hash of lambdas with default filters for `all_members`
-        #
-        DEFAULT_FILTERS = {
-          groups: ->(item) { item.is_a?(Java::OrgOpenhabCoreItems::GroupItem) },
-          all: -> { true }
-        }.freeze
+          # Send a command to each member of the group
+          #
+          # @return [GroupMembers] +self+
+          def command(command)
+            each { |item| item << command }
+          end
+          alias << command
 
-        private_constant :DEFAULT_FILTERS
+          # @!method refresh
+          #   Send the +REFRESH+ command to each member of the group
+          #   @return [GroupMembers] +self+
 
-        #
-        # Create a new GroupItem
-        #
-        # @param [Java::Org::openhab::core::items::GroupItem] group_item OpenHAB GroupItem to delegate to
-        #
-        def initialize(group_item)
-          @group_item = group_item
+          # @!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+
 
-          item_missing_delegate { @group_item }
-          item_missing_delegate { OpenHAB::Core::EntityLookup.decorate_item(base_item) }
+          # @!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
+        include ComparableItem
+
+        remove_method :==
+
         #
-        # Create a GroupMembers object for use in triggers
+        # Get an Array-like object representing the members of the group
         #
-        # @return [GroupMembers] A GroupMembers object
+        # @return [GroupMembers]
         #
         def members
-          GroupMembers.new(@group_item)
+          GroupMembers.new(self)
         end
+
+        # @deprecated
         alias items members
 
         #
@@ -89,51 +129,43 @@ module OpenHAB
         # Get all members of the group recursively. Optionally filter the items to only return
         # Groups or regular Items
         #
-        # @param [Symbol] filter Either :groups or :items
+        # @param [Symbol] filter Either +:groups+ or +:items+
         #
         # @return [Array] An Array containing all descendants of the Group, optionally filtered
         #
         def all_members(filter = nil, &block)
-          predicate = DEFAULT_FILTERS[filter] || block
+          filter = nil if filter == :items
+          raise ArgumentError, 'filter must be :groups or :items' unless [:groups, nil].include?(filter)
 
-          return OpenHAB::Core::EntityLookup.decorate_items(@group_item.all_members.to_a) unless predicate
+          block = ->(i) { i.is_a?(GroupItem) } if filter
 
-          OpenHAB::Core::EntityLookup.decorate_items(@group_item.get_members(&predicate).to_a)
-        end
-
-        #
-        # Test for equality
-        #
-        # @param [Object] other Other object to compare against
-        #
-        # @return [Boolean] true if self and other can be considered equal, false otherwise
-        #
-        def ==(other)
-          if other.respond_to?(:java_class) && accepted_data_types.include?(other.java_class)
-            get_state_as(other.class) == other
-          elsif other.respond_to?(:state)
-            base_item ? OpenHAB::Core::EntityLookup.decorate_item(base_item) == other.state : self == other.state
+          if block
+            get_members(&block).to_a
           else
-            super
+            get_all_members.to_a
           end
         end
 
-        #
-        # Compare GroupItem 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)
-          if base_item
-            OpenHAB::Core::EntityLookup.decorate_item(base_item) <=> other
-          elsif state?
-            -(other <=> state)
-          else
-            super
-          end
+        # Delegate missing methods to +base_item+ if possible
+        def method_missing(method, *args, &block)
+          return base_item.__send__(method, *args, &block) if base_item.respond_to?(method)
+
+          super
+        end
+
+        # @!visibility private
+        def respond_to_missing?(method, include_private = false)
+          return true if base_item.respond_to?(method)
+
+          super
+        end
+
+        # give the base item type a chance to format commands
+        # @!visibility private
+        def format_type(command)
+          return super unless base_item
+
+          base_item.format_type(command)
         end
       end
     end

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

@@ -3,52 +3,16 @@
 require 'base64'
 require 'pathname'
 require 'net/http'
-require 'java'
 require 'marcel'
-require 'openhab/dsl/items/item_command'
-require 'openhab/dsl/items/item_delegate'
 
 module OpenHAB
   module DSL
     module Items
-      #
-      # Delegator to OpenHAB Player Item
-      #
-      class ImageItem
-        extend OpenHAB::DSL::Items::ItemCommand
-        extend OpenHAB::DSL::Items::ItemDelegate
-
-        def_item_delegator :@image_item
-
-        item_type Java::OrgOpenhabCoreLibraryItems::ImageItem
-
-        #
-        # Creates a new ImageItem
-        #
-        # @param [Java::OrgOpenhabCoreLibraryItems::ImageItem] image_item
-        #   The OpenHAB ImageItem to delegate to
-        #
-        def initialize(image_item)
-          logger.trace("Wrapping #{image_item}")
-          @image_item = image_item
-
-          item_missing_delegate { @image_item }
-
-          super()
-        end
-
-        #
-        #
-        # Update image with base64 encoded OpenHAB compatable image
-        #
-        # @param [String] base_64 base_64 encoding of an image
-        #
-        #
-        def update(base_64_encoded_image)
-          logger.trace { "Updating #{self} with Base64 image #{base_64_encoded_image}" }
-          @image_item.update base_64_encoded_image
-        end
+      java_import org.openhab.core.library.items.ImageItem
 
+      # Adds methods to core OpenHAB ImageItem type to make it more natural in
+      # Ruby
+      class ImageItem < GenericItem
         #
         # Update image from file
         #
@@ -87,7 +51,7 @@ module OpenHAB
         def update_from_bytes(bytes, mime_type: nil)
           mime_type ||= detect_mime_from_bytes(bytes: bytes)
           base_64_image = encode_image(mime_type: mime_type, bytes: bytes)
-          update base_64_image
+          update(base_64_image)
         end
 
         #

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+require 'openhab/core/entity_lookup'
+require 'openhab/dsl/lazy_array'
+
+module OpenHAB
+  module DSL
+    module Items
+      #
+      # Provides access to all OpenHAB items, and acts like an array.
+      #
+      class ItemRegistry
+        include LazyArray
+        include Singleton
+
+        # Fetches the named item from the the ItemRegistry
+        # @param [String] name
+        # @return [GenericItem] Item from registry, nil if item missing or requested item is a Group Type
+        def [](name)
+          OpenHAB::Core::EntityLookup.lookup_item(name)
+        rescue org.openhab.core.items.ItemNotFoundException
+          nil
+        end
+
+        # Returns true if the given item name exists
+        # @param name [String] Item name to check
+        # @return [Boolean] true if the item exists, false otherwise
+        def include?(name)
+          !$ir.getItems(name).empty? # rubocop: disable Style/GlobalVars
+        end
+        alias key? include?
+
+        # Explicit conversion to array
+        # @return [Array]
+        def to_a
+          $ir.items.grep_v(org.openhab.core.items.GroupItem) # rubocop:disable Style/GlobalVars
+        end
+      end
+
+      # Fetches all non-group items from the item registry
+      # @return [ItemRegistry]
+      def items
+        ItemRegistry.instance
+      end
+    end
+  end
+end