openhab-scripting 4.46.2 → 5.0.0

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

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'numeric_item'
-
-module OpenHAB
-  module DSL
-    #
-    # Patches OpenHAB items
-    #
-    module Items
-      java_import org.openhab.core.library.items.DimmerItem
-
-      # Alias class
-      ::Dimmer = DimmerItem
-
-      # Adds methods to core OpenHAB DimmerItem type to make it more natural in
-      # Ruby
-      class DimmerItem < SwitchItem
-        include NumericItem
-
-        #
-        # Dim the dimmer
-        #
-        # @param [Integer] amount to dim by
-        #
-        # @return [Integer] level target for dimmer
-        #
-        def dim(amount = 1)
-          target = [state&.-(amount), 0].compact.max
-          command(target)
-          target
-        end
-
-        #
-        # Brighten the dimmer
-        #
-        # @param [Integer] amount to brighten by
-        #
-        # @return [Integer] level target for dimmer
-        #
-        def brighten(amount = 1)
-          target = [state&.+(amount), 100].compact.min
-          command(target)
-          target
-        end
-
-        # @!method increase
-        #   Send the +INCREASE+ command to the item
-        #   @return [DimmerItem] +self+
-
-        # @!method decrease
-        #   Send the +DECREASE+ command to the item
-        #   @return [DimmerItem] +self+
-
-        # raw numbers translate directly to PercentType, not a DecimalType
-        # @!visibility private
-        def format_type(command)
-          return Types::PercentType.new(command) if command.is_a?(Numeric)
-
-          super
-        end
-      end
-    end
-  end
-end

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

@@ -1,229 +0,0 @@
-# frozen_string_literal: true
-
-require 'delegate'
-require 'forwardable'
-
-require_relative 'metadata'
-require_relative 'persistence'
-require_relative 'semantics'
-
-require_relative 'item_equality'
-
-module OpenHAB
-  module DSL
-    module Items
-      java_import org.openhab.core.items.GenericItem
-
-      # Adds methods to core OpenHAB GenericItem type to make it more natural in
-      # Ruby
-      #
-      # @see https://www.openhab.org/javadoc/latest/org/openhab/core/items/genericitem
-      class GenericItem
-        include Log
-        include ItemEquality
-
-        prepend Metadata
-        prepend Persistence
-        include Semantics
-
-        # 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
-
-          #
-          # Override to support ItemProxy
-          #
-          def ===(other)
-            other.instance_of?(self)
-          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
-        alias truthy? state?
-
-        #
-        # 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] }.compact
-        end
-
-        # Return the item's thing if this item is linked with a thing. If an item is linked to more than one thing,
-        # this method only returns the first thing.
-        #
-        # @return [Thing] The thing associated with this item or nil
-        def thing
-          all_linked_things.first
-        end
-        alias linked_thing thing
-
-        # Returns all of the item's linked things.
-        #
-        # @return [Array] An array of things or an empty array
-        def things
-          registry = OpenHAB::Core::OSGI.service('org.openhab.core.thing.link.ItemChannelLinkRegistry')
-          channels = registry.get_bound_channels(name).to_a
-          channels.map(&:thing_uid).uniq.map { |tuid| OpenHAB::DSL::Things.things[tuid] }
-        end
-        alias all_linked_things things
-
-        #
-        # 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
-
-        #
-        # A method to indicate that item comparison is requested instead of state comparison
-        #
-        # Example: Item1.item == items['Item1'].item should return true
-        #
-        # See ItemEquality#==
-        #
-        def item
-          @item ||= GenericItemObject.new(self)
-        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
-
-    # A helper class to flag that item comparison is wanted instead of state comparison
-    # It is used by ItemEquality#===
-    class GenericItemObject < SimpleDelegator
-      extend Forwardable
-      include Log
-      include OpenHAB::DSL::Items::ItemEquality
-
-      def_delegator :__getobj__, :instance_of? # instance_of? is used by GenericItem#eql? to check for item equality
-    end
-  end
-end

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

@@ -1,127 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'comparable_item'
-require 'openhab/dsl/lazy_array'
-
-module OpenHAB
-  module DSL
-    module Items
-      java_import org.openhab.core.items.GroupItem
-
-      # Adds methods to core OpenHAB GroupItem type to make it more natural in
-      # Ruby
-      class GroupItem < GenericItem
-        #
-        # Class for indicating to triggers that a group trigger should be used
-        #
-        class GroupMembers
-          include LazyArray
-
-          # @return [GroupItem]
-          attr_reader :group
-
-          # @!visibility private
-          def initialize(group_item)
-            @group = group_item
-          end
-
-          # Explicit conversion to Array
-          #
-          # @return [Array]
-          def to_a
-            group.get_members.map { |i| ::OpenHAB::Core::ItemProxy.new(i) }
-          end
-
-          # Name of the group
-          #
-          # @return [String]
-          def name
-            group.name
-          end
-
-          alias << command
-        end
-
-        include Enumerable
-        include ComparableItem
-        prepend Semantics # make Semantics#points take precedence over Enumerable#points for GroupItem
-
-        remove_method :==
-
-        # Override Enumerable because we want to send them to the base item if possible
-        #
-        # @return [GroupMembers] +self+
-        %i[command update].each do |method|
-          define_method(method) do |command|
-            return base_item.__send__(method, command) if base_item
-
-            super(command)
-          end
-        end
-
-        #
-        # Get an Array-like object representing the members of the group
-        #
-        # @return [GroupMembers]
-        #
-        def members
-          GroupMembers.new(self)
-        end
-
-        # @deprecated
-        alias items members
-
-        #
-        # Iterates through the direct members of the Group
-        #
-        def each(&block)
-          members.each(&block)
-        end
-
-        #
-        # 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+
-        #
-        # @return [Array] An Array containing all descendants of the Group, optionally filtered
-        #
-        def all_members(filter = nil, &block)
-          filter = nil if filter == :items
-          raise ArgumentError, 'filter must be :groups or :items' unless [:groups, nil].include?(filter)
-
-          block = ->(i) { i.is_a?(GroupItem) } if filter
-
-          if block
-            get_members(&block).to_a
-          else
-            get_all_members.to_a
-          end
-        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
-
-        # Is this ever called?
-        # 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
-  end
-end

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

@@ -1,59 +0,0 @@
-# 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 { "ItemEquality#== (#{self.class}) #{self} == #{other} (#{other.class})" }
-          return eql?(other) if generic_item_object?(other)
-          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
-
-        #
-        # Check item object equality for grep
-        #
-        def ===(other)
-          logger.trace { "ItemEquality#=== (#{self.class}) #{self} == #{other} (#{other.class})" }
-          eql?(other)
-        end
-
-        private
-
-        #
-        # Determines if an object equality check is required, based on whether
-        # either operand is a GenericItemObject
-        #
-        # @param [Object] other
-        #
-        # @return [Boolean]
-        #
-        def generic_item_object?(other)
-          other.is_a?(OpenHAB::DSL::GenericItemObject) || is_a?(OpenHAB::DSL::GenericItemObject)
-        end
-      end
-    end
-  end
-end

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

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-require 'singleton'
-
-require 'openhab/core/entity_lookup'
-require 'openhab/dsl/lazy_array'
-
-module OpenHAB
-  module DSL
-    module Items
-      module_function
-
-      # Fetches all non-group items from the item registry
-      # @return [ItemRegistry]
-      def items
-        OpenHAB::DSL::Support::ItemRegistry.instance
-      end
-    end
-
-    # Provide supporting objects for DSL functions
-    module Support
-      #
-      # 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?
-        end
-        alias key? include?
-
-        # Explicit conversion to array
-        # @return [Array]
-        def to_a
-          $ir.items.map { |item| OpenHAB::Core::ItemProxy.new(item) }
-        end
-      end
-    end
-  end
-end

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

@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-require 'openhab/dsl/monkey_patch/events/item_command'
-require 'openhab/dsl/types/types'
-
-require_relative 'item_registry'
-
-require_relative 'generic_item'
-require_relative 'switch_item'
-require_relative 'date_time_item'
-require_relative 'dimmer_item'
-require_relative 'color_item'
-require_relative 'contact_item'
-require_relative 'group_item'
-require_relative 'image_item'
-require_relative 'location_item'
-require_relative 'number_item'
-require_relative 'player_item'
-require_relative 'rollershutter_item'
-require_relative 'string_item'
-
-require_relative 'ensure'
-require_relative 'timed_command'
-
-module OpenHAB
-  module DSL
-    # Contains all OpenHAB *Item classes, as well as associated support
-    # modules
-    module Items
-      include OpenHAB::Log
-
-      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
-
-        # 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 = OpenHAB::DSL::PREDICATE_ALIASES[state.to_s]
-            next if klass.instance_methods.include?(state_predicate)
-
-            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
-
-        # 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 = OpenHAB::DSL::COMMAND_ALIASES[value.to_s]
-            next if klass.instance_methods.include?(command)
-
-            logger.trace("Defining #{klass}##{command} for #{value}")
-            klass.class_eval <<~RUBY, __FILE__, __LINE__ + 1
-              def #{command}(for: nil, on_expire: nil, &block)                                          # def on(for: nil, on_expire: nil, &block )
-                command(#{value}, for: binding.local_variable_get(:for), on_expire: on_expire, &block)  #   command(ON, for: nil, expire: nil, &block)
-              end                                                                                       # end
-            RUBY
-
-            logger.trace("Defining Enumerable##{command} for #{value}")
-            Enumerable.class_eval <<~RUBY, __FILE__, __LINE__ + 1
-              def #{command}        # def on
-                each(&:#{command})  #   each(&:on)
-              end                   # end
-            RUBY
-
-            # Override the inherited methods from Enumerable and send it to the base_item
-            GroupItem.class_eval <<~RUBY, __FILE__, __LINE__ + 1
-              def #{command}                 # def on
-                method_missing(:#{command})  #   method_missing(:on)
-              end                            # end
-            RUBY
-
-            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
-
-      # 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
-end

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

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-require 'forwardable'
-
-require_relative 'comparable_item'
-require 'openhab/dsl/types/point_type'
-
-module OpenHAB
-  module DSL
-    module Items
-      java_import org.openhab.core.library.items.LocationItem
-
-      # Adds methods to core OpenHAB NumberItem type to make it more natural in
-      # Ruby
-      class LocationItem < GenericItem
-        extend Forwardable
-        include ComparableItem
-
-        # !@visibility private
-        def ==(other)
-          # need to check if we're referring to the same item before
-          # forwarding to <=> (and thus checking equality with state)
-          return true if equal?(other) || eql?(other)
-
-          super
-        end
-
-        # Support conversion to location items from a hash
-        # @!visibility private
-        def format_type(command)
-          return PointType.new(command.to_hash) if command.respond_to?(:to_hash)
-
-          super
-        end
-
-        # Type Coercion
-        #
-        # Coerce object to a PointType
-        #
-        # @param [Types::PointType, String] other object to coerce to a
-        #   PointType
-        #
-        # @return [[Types::PointType, Types::PointType]]
-        #
-        def coerce(other)
-          logger.trace("Coercing #{self} as a request from #{other.class}")
-          return [other, nil] unless state?
-          return [other, state] if other.is_a?(Types::PointType) || other.respond_to?(:to_str)
-        end
-
-        # OpenHAB has this method, but it _only_ accepts PointType, so remove it and delegate
-        remove_method :distance_from
-
-        # any method that exists on {Types::PointType} gets forwarded to +state+
-        delegate (Types::PointType.instance_methods - instance_methods) => :state
-      end
-    end
-  end
-end