openhab-scripting 4.1.3 → 4.4.0

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

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

@@ -1,52 +1,97 @@
 # frozen_string_literal: true
 
-require 'java'
-require 'singleton'
+require 'openhab/dsl/monkey_patch/events/item_command'
 
-require 'openhab/core/entity_lookup'
-require 'openhab/dsl/lazy_array'
+require_relative 'item_registry'
+
+require_relative 'generic_item'
+
+require_relative 'switch_item'
+require_relative 'date_time_item'
+require_relative 'dimmer_item'
+
+require_relative 'contact_item'
+require_relative 'group_item'
+require_relative 'image_item'
+require_relative 'number_item'
+require_relative 'player_item'
+require_relative 'rollershutter_item'
+require_relative 'string_item'
+
+require_relative 'ensure'
 
 module OpenHAB
   module DSL
-    #
-    # Manages OpenHAB items
-    #
+    # Contains all OpenHAB *Item classes, as well as associated support
+    # modules
     module Items
-      #
-      # Delegates to underlying set of all OpenHAB Items, provides convenience methods
-      #
-      class Items
-        include LazyArray
-        include Singleton
-
-        # Fetches the named item from the the ItemRegistry
-        # @param [String] name
-        # @return Item from registry, nil if item missing or requested item is a Group Type
-        def [](name)
-          OpenHAB::Core::EntityLookup.lookup_item(name)
-        rescue Java::OrgOpenhabCoreItems::ItemNotFoundException
-          nil
+      class << self
+        private
+
+        # takes an array of Type java classes and returns
+        # all the Enum values, in a flat array
+        def values_for_enums(enums)
+          enums.map(&:ruby_class)
+               .select { |k| k < java.lang.Enum }
+               .flat_map(&:values)
         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
+        # define predicates for checking if an item is in one of the Enum states
+        def def_predicate_methods(klass)
+          values_for_enums(klass.ACCEPTED_DATA_TYPES).each do |state|
+            _command_predicate, state_predicate = Types::PREDICATE_ALIASES[state.to_s]
+            next if klass.instance_methods.include?(state_predicate)
+
+            OpenHAB::Core.logger.trace("Defining #{klass}##{state_predicate} for #{state}")
+            klass.class_eval <<~RUBY, __FILE__, __LINE__ + 1
+              def #{state_predicate}   # def on?
+                raw_state == #{state}  #   raw_state == ON
+              end                      # end
+            RUBY
+          end
         end
-        alias key? []
 
-        # explicit conversion to array
-        def to_a
-          items = $ir.items.grep_v(org.openhab.core.items.GroupItem) # rubocop:disable Style/GlobalVars
-          OpenHAB::Core::EntityLookup.decorate_items(items)
+        # defined methods for commanding an item to one of the Enum states
+        # as well as predicates for if an ItemCommandEvent is one of those commands
+        def def_command_methods(klass) # rubocop:disable Metrics method has single purpose
+          values_for_enums(klass.ACCEPTED_COMMAND_TYPES).each do |value|
+            command = Types::COMMAND_ALIASES[value.to_s]
+            next if klass.instance_methods.include?(command)
+
+            OpenHAB::Core.logger.trace("Defining #{klass}##{command} for #{value}")
+            klass.class_eval <<~RUBY, __FILE__, __LINE__ + 1
+              def #{command}       # def on
+                command(#{value})  #   command(ON)
+              end                  # end
+            RUBY
+
+            OpenHAB::Core.logger.trace("Defining GroupItem::GroupMembers##{command} for #{value}")
+            GroupItem::GroupMembers.class_eval <<~RUBY, __FILE__, __LINE__ + 1
+              def #{command}        # def on
+                each(&:#{command})  #   each(&:on)
+              end                   # end
+            RUBY
+
+            OpenHAB::Core.logger.trace("Defining ItemCommandEvent##{command}? for #{value}")
+            MonkeyPatch::Events::ItemCommandEvent.class_eval <<~RUBY, __FILE__, __LINE__ + 1
+              def #{command}?        # def refresh?
+                command == #{value}  #   command == REFRESH
+              end                    # end
+            RUBY
+          end
         end
       end
 
-      # Fetches all non-group items from the item registry
-      # @return [OpenHAB::DSL::Items::Items]
-      def items
-        Items.instance
+      # sort classes by hierarchy so we define methods on parent classes first
+      constants.map { |c| const_get(c) }
+               .grep(Module)
+               .select { |k| k <= GenericItem && k != GroupItem && k != StringItem }
+               .sort { |a, b| a < b ? 1 : -1 }
+               .each do |klass|
+        klass.field_reader :ACCEPTED_COMMAND_TYPES, :ACCEPTED_DATA_TYPES unless klass == GenericItem
+
+        def_predicate_methods(klass)
+        def_command_methods(klass)
       end
     end
   end