openhab-scripting 4.46.2 → 5.0.0

data/lib/openhab/dsl/types/open_closed_type.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module OpenHAB
-  module DSL
-    module Types
-      OpenClosedType = org.openhab.core.library.types.OpenClosedType
-
-      # Adds methods to core OpenHAB OpenClosedType to make it more natural in Ruby
-      class OpenClosedType
-        # @!parse include Type
-
-        # @!method open?
-        #   Check if == +OPEN+
-        #   @return [Boolean]
-
-        # @!method closed?
-        #   Check if == +CLOSED+
-        #   @return [Boolean]
-
-        # Invert the type
-        # @return [OpenClosedType] +OPEN+ if +CLOSED+, +CLOSED+ if +OPEN+
-        def !
-          return CLOSED if open?
-          return OPEN if closed?
-        end
-      end
-    end
-  end
-end

data/lib/openhab/dsl/types/play_pause_type.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module OpenHAB
-  module DSL
-    module Types
-      PlayPauseType = org.openhab.core.library.types.PlayPauseType
-
-      # Adds methods to core OpenHAB PlayPauseType to make it more
-      # natural in Ruby
-      class PlayPauseType # rubocop:disable Lint/EmptyClass
-        # @!parse include Type
-
-        # @!method playing?
-        #   Check if == +PLAY+
-        #   @return [Boolean]
-
-        # @!parse alias play? playing?
-
-        # @!method paused?
-        #   Check if == +PAUSE+
-        #   @return [Boolean]
-
-        # @!parse alias pause? paused?
-      end
-    end
-  end
-end

data/lib/openhab/dsl/types/point_type.rb

@@ -1,180 +0,0 @@
-# frozen_string_literal: true
-
-module OpenHAB
-  module DSL
-    module Types
-      PointType = org.openhab.core.library.types.PointType
-
-      # global scope - required for jrubyscripting addon <= OH3.2.0
-      # @!visibility private
-      ::PointType = PointType if ::PointType.is_a?(java.lang.Class)
-
-      # Adds methods to core OpenHAB PointType to make it more natural in Ruby
-      class PointType
-        # @!parse include PrimitiveType
-
-        # @overload initialize(latitude, longitude, altitude)
-        #   @param [DecimalType, QuantityType, StringType, Numeric] latitude
-        #   @param [DecimalType, QuantityType, StringType, Numeric] longitude
-        #   @param [DecimalType, QuantityType, StringType, Numeric] altitude
-        def initialize(*args) # rubocop:disable Metrics
-          args = from_hash(args.first.to_hash) if args.first.respond_to? :to_hash
-          if (2..3).cover?(args.length)
-            args = args.each_with_index.map do |value, index|
-              if value.is_a?(DecimalType) || value.is_a?(StringType)
-                value
-              elsif value.is_a?(QuantityType)
-                unit = index == 2 ? Units.unit || SIUnits::METRE : Units::DEGREE_ANGLE
-                DecimalType.new(value.to_unit(unit).to_big_decimal)
-              elsif value.respond_to?(:to_str)
-                StringType.new(value.to_str)
-              elsif value.respond_to?(:to_d)
-                DecimalType.new(value)
-              end
-            end
-          end
-
-          super(*args)
-        end
-
-        #
-        # Check equality without type conversion
-        #
-        # @return [Boolean] if the same value is represented, without type
-        #   conversion
-        def eql?(other)
-          return false unless other.instance_of?(self.class)
-
-          equals(other.to_s).zero?
-        end
-
-        #
-        # Check equality with type conversion
-        #
-        # @param [PointType, Items::LocationItem, String]
-        #   other object to compare to
-        #
-        # @return [Boolean]
-        #
-        def ==(other) # rubocop:disable Metrics
-          logger.trace { "(#{self.class}) #{self} == #{other} (#{other.class})" }
-          if other.is_a?(Items::LocationItem) ||
-             (other.is_a?(Items::GroupItem) && other.base_item.is_a?(LocationItem))
-            return false unless other.state?
-
-            self == other.state
-          elsif other.respond_to?(:to_str)
-            self == PointType.new(other)
-          elsif other.respond_to?(:coerce)
-            return false unless (lhs, rhs = other.coerce(self))
-
-            lhs == rhs
-          end
-        end
-
-        #
-        # Type Coercion
-        #
-        # Coerce object to a PointType
-        #
-        # @param [Items::LocationItem, String] other object to coerce to a
-        #   PointType
-        #
-        # @return [[PointType, PointType]]
-        #
-        def coerce(other)
-          lhs = coerce_single(other)
-          return unless lhs
-
-          [lhs, self]
-        end
-
-        # rename raw methods so we can overwrite them
-        # @!visibility private
-        alias raw_latitude latitude
-        # .
-        # @!visibility private
-        alias raw_longitude longitude
-        # .
-        # @!visibility private
-        alias raw_altitude altitude
-        # .
-        # @!visibility private
-        alias raw_distance_from distance_from
-
-        # @!attribute [r] latitude
-        # @return [QuantityType]
-        def latitude
-          QuantityType.new(raw_latitude.to_big_decimal, SIUnits::DEGREE_ANGLE)
-        end
-
-        # @!attribute [r] longitude
-        # @return [QuantityType]
-        def longitude
-          QuantityType.new(raw_longitude.to_big_decimal, SIUnits::DEGREE_ANGLE)
-        end
-
-        # @!attribute [r] altitude
-        # @return [QuantityType]
-        def altitude
-          QuantityType.new(raw_altitude.to_big_decimal, Units::METRE)
-        end
-
-        #
-        # Convert the PointType to a hash
-        # @return [Hash] with keys latitude/longitude/altitude
-        def to_h
-          { latitude: latitude, longitude: longitude, altitude: altitude }
-        end
-
-        #
-        # Calculate the distance in meters from other, ignoring altitude.
-        #
-        # This algorithm also ignores the oblate spheroid shape of Earth and
-        # assumes a perfect sphere, so results are inexact.
-        #
-        # @return [QuantityType]
-        def distance_from(other)
-          logger.trace("(#{self}).distance_from(#{other} (#{other.class})")
-          other = coerce_single(other)
-          raise TypeError, "#{other.class} can't be coerced into #{self.class}" unless other
-
-          QuantityType.new(raw_distance_from(other), SIUnits::METRE)
-        end
-        alias - distance_from
-
-        private
-
-        # coerce an object to a PointType
-        # @return [PointType]
-        def coerce_single(other) # rubocop:disable Metrics
-          logger.trace("Coercing #{self} as a request from #{other.class}")
-          if other.is_a?(PointType)
-            other
-          elsif other.is_a?(Items::LocationItem)
-            return unless other.state?
-
-            other.state
-          elsif other.respond_to?(:to_str)
-            PointType.new(other.to_str)
-          elsif other.respond_to?(:to_hash)
-            PointType.new(other.to_hash)
-          end
-        end
-
-        #
-        # Convert hash into ordered arguments for constructor
-        #
-        def from_hash(hash)
-          keys = [%i[lat long alt], %i[latitude longitude altitude]]
-          keys.each do |key_set|
-            values = hash.transform_keys(&:to_sym).values_at(*key_set)
-
-            return *values.compact if values[0..1].all?
-          end
-          raise ArgumentError, "Supplied arguments (#{hash}) must contain one of the following sets #{keys}"
-        end
-      end
-    end
-  end
-end

data/lib/openhab/dsl/types/quantity_type.rb

@@ -1,265 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'numeric_type'
-
-module OpenHAB
-  module DSL
-    module Types
-      QuantityType = org.openhab.core.library.types.QuantityType
-
-      # global alias - required for jrubyscripting addon <= OH3.2.0
-      ::QuantityType = QuantityType if ::QuantityType.is_a?(java.lang.Class)
-
-      # @deprecated
-      # Backwards-compatible alias
-      Quantity = QuantityType
-
-      # Adds methods to core OpenHAB QuantityType to make it more natural in Ruby
-      class QuantityType # rubocop:disable Metrics/ClassLength
-        # @!parse include Type
-        include NumericType
-
-        # private alias
-        ONE_UNIT = org.openhab.core.library.unit.Units::ONE
-        private_constant :ONE_UNIT
-
-        #
-        # Convert this quantity into a another unit
-        #
-        alias | to_unit
-
-        #
-        # Comparison
-        #
-        # @param [NumericType, Items::NumericItem, Numeric, String]
-        #   other object to compare to
-        #
-        # @return [Integer, nil] -1, 0, +1 depending on whether +other+ is
-        #   less than, equal to, or greater than self
-        #
-        #   nil is returned if the two values are incomparable
-        #
-        def <=>(other) # rubocop:disable Metrics
-          logger.trace("(#{self.class}) #{self} <=> #{other} (#{other.class})")
-          if other.is_a?(self.class)
-            return unitize(other.unit).compare_to(other) if unit == ONE_UNIT
-            return compare_to(other.unitize(unit)) if other.unit == ONE_UNIT
-
-            compare_to(other)
-          elsif other.is_a?(Items::NumericItem) ||
-                (other.is_a?(Items::GroupItem) && other.base_item.is_a?(NumericItem))
-            return nil unless other.state?
-
-            self <=> other.state
-          elsif other.respond_to?(:to_str)
-            compare_to(QuantityType.new(other.to_str))
-          elsif other.respond_to?(:to_d)
-            compare_to(QuantityType.new(other.to_d.to_java, Units.unit || unit))
-          elsif other.respond_to?(:coerce)
-            return nil unless (lhs, rhs = other.coerce(self))
-
-            lhs <=> rhs
-          end
-        end
-
-        #
-        # Type Coercion
-        #
-        # Coerce object to a QuantityType
-        #
-        # @param [Items::NumericItem, Numeric, Type, String] other object to
-        #   coerce to a {QuantityType}
-        #
-        #   if +other+ is a {Type}, +self+ will instead be coerced
-        #   to that type to accomodate comparison with things such as {OnOffType}
-        #
-        # @return [[QuantityType, QuantityType]]
-        def coerce(other) # rubocop:disable Metrics
-          logger.trace("Coercing #{self} as a request from #{other.class}")
-          if other.is_a?(Items::NumericItem) ||
-             (other.is_a?(Items::GroupItem) && other.base_item.is_a?(Items::NumericItem))
-            return unless other.state?
-
-            [other.state, self]
-          elsif other.is_a?(Type)
-            [other, as(other.class)]
-          elsif other.respond_to?(:to_d)
-            [QuantityType.new(other.to_d.to_java, ONE_UNIT), self]
-          elsif other.is_a?(String)
-            [QuantityType.new(other), self]
-          end
-        end
-
-        # arithmetic operators
-        alias -@ negate
-
-        {
-          :add => :+,
-          :subtract => :-
-        }.each do |java_op, ruby_op|
-          convert = 'self.class.new(other, Units.unit || unit)'
-
-          class_eval( # rubocop:disable Style/DocumentDynamicEvalDefinition https://github.com/rubocop/rubocop/issues/10179
-            # def +(other)
-            #   logger.trace("#{self} + #{other} (#{other.class})")
-            #   if other.is_a?(Items::NumericItem) ||
-            #     (other.is_a?(Items::GroupItem) && other.base_item.is_a?(Items::NumericItem))
-            #     self + other.state
-            #   elsif other.is_a?(QuantityType)
-            #     add_quantity(other)
-            #   elsif other.is_a?(DecimalType)
-            #     other = other.to_big_decimal
-            #     add_quantity(self.class.new(other, Units.unit || unit))
-            #   elsif other.is_a?(java.math.BigDecimal)
-            #     add_quantity(self.class.new(other, Units.unit || unit))
-            #   elsif other.respond_to?(:to_str)
-            #     self + self.class.new(other)
-            #   elsif other.respond_to?(:to_d)
-            #     other = other.to_d.to_java
-            #     add_quantity(self.class.new(other, Units.unit || unit))
-            #   elsif other.respond_to?(:coerce) && (lhs, rhs = other.coerce(to_d))
-            #     lhs + rhs
-            #   else
-            #     raise TypeError, "#{other.class} can't be coerced into #{self.class}"
-            #   end
-            # end
-            <<~RUBY, __FILE__, __LINE__ + 1
-              def #{ruby_op}(other)
-                logger.trace("\#{self} #{ruby_op} \#{other} (\#{other.class})")
-                if other.is_a?(Items::NumericItem) ||
-                  (other.is_a?(Items::GroupItem) && other.base_item.is_a?(Items::NumericItem))
-                  self #{ruby_op} other.state
-                elsif other.is_a?(QuantityType)
-                  #{java_op}_quantity(other)
-                elsif other.is_a?(DecimalType)
-                  other = other.to_big_decimal
-                  #{java_op}_quantity(#{convert})
-                elsif other.is_a?(java.math.BigDecimal)
-                  #{java_op}_quantity(#{convert})
-                elsif other.respond_to?(:to_str)
-                  self #{ruby_op} self.class.new(other)
-                elsif other.respond_to?(:to_d)
-                  other = other.to_d.to_java
-                  #{java_op}_quantity(#{convert})
-                elsif other.respond_to?(:coerce) && (lhs, rhs = other.coerce(to_d))
-                  lhs #{ruby_op} rhs
-                else
-                  raise TypeError, "\#{other.class} can't be coerced into \#{self.class}"
-                end
-              end
-            RUBY
-          )
-        end
-
-        {
-          :multiply => :*,
-          :divide => :/
-        }.each do |java_op, ruby_op|
-          class_eval( # rubocop:disable Style/DocumentDynamicEvalDefinition https://github.com/rubocop/rubocop/issues/10179
-            # def *(other)
-            #   logger.trace("#{self} * #{other} (#{other.class})")
-            #   if other.is_a?(Items::NumericItem) ||
-            #       (other.is_a?(Items::GroupItem) && other.base_item.is_a?(Items::NumericItem))
-            #     self * other.state
-            #   elsif other.is_a?(QuantityType)
-            #     multiply_quantity(other)
-            #   elsif other.is_a?(DecimalType)
-            #     multiply(other.to_big_decimal)
-            #   elsif other.is_a?(java.math.BigDecimal)
-            #     multiply(other)
-            #   elsif other.respond_to?(:to_str)
-            #     self * self.class.new(other)
-            #   elsif other.respond_to?(:to_d)
-            #     multiply(other.to_d.to_java)
-            #   elsif other.respond_to?(:coerce) && (lhs, rhs = other.coerce(to_d))
-            #     lhs * rhs
-            #   else
-            #     raise TypeError, "#{other.class} can't be coerced into #{self.class}"
-            #   end
-            # end
-            <<~RUBY, __FILE__, __LINE__ + 1
-              def #{ruby_op}(other)
-                logger.trace("\#{self} #{ruby_op} \#{other} (\#{other.class})")
-                if other.is_a?(Items::NumericItem) ||
-                   (other.is_a?(Items::GroupItem) && other.base_item.is_a?(Items::NumericItem))
-                  self #{ruby_op} other.state
-                elsif other.is_a?(QuantityType)
-                  #{java_op}_quantity(other)
-                elsif other.is_a?(DecimalType)
-                  #{java_op}(other.to_big_decimal)
-                elsif other.is_a?(java.math.BigDecimal)
-                  #{java_op}(other)
-                elsif other.respond_to?(:to_str)
-                  self #{ruby_op} self.class.new(other)
-                elsif other.respond_to?(:to_d)
-                  #{java_op}(other.to_d.to_java)
-                elsif other.respond_to?(:coerce) && (lhs, rhs = other.coerce(to_d))
-                  lhs #{ruby_op} rhs
-                else
-                  raise TypeError, "\#{other.class} can't be coerced into \#{self.class}"
-                end
-              end
-            RUBY
-          )
-        end
-
-        # if it's a dimensionless quantity, change the unit to match other_unit
-        # @!visibility private
-        def unitize(other_unit = unit)
-          # prefer converting to the thread-specified unit if there is one
-          other_unit = Units.unit || other_unit
-          logger.trace("Converting #{self} to #{other_unit}")
-
-          case unit
-          when ONE_UNIT
-            QuantityType.new(to_big_decimal, other_unit)
-          when other_unit
-            self
-          else
-            to_unit(other_unit)
-          end
-        end
-
-        # if unit is +ONE_UNIT+, return a plain Java BigDecimal
-        # @!visibility private
-        def deunitize
-          return to_big_decimal if unit == ONE_UNIT
-
-          self
-        end
-
-        private
-
-        # do addition directly against a QuantityType while ensuring we unitize
-        # both sides
-        def add_quantity(other)
-          unitize(other.unit).add(other.unitize(unit))
-        end
-
-        # do subtraction directly against a QuantityType while ensuring we
-        # unitize both sides
-        def subtract_quantity(other)
-          unitize(other.unit).subtract(other.unitize(unit))
-        end
-
-        # do multiplication directly against a QuantityType while ensuring
-        # we deunitize both sides, and also invert the operation if one side
-        # isn't actually a unit
-        def multiply_quantity(other)
-          lhs = deunitize
-          rhs = other.deunitize
-          # reverse the arguments if it's multiplication and the LHS isn't a QuantityType
-          lhs, rhs = rhs, lhs if lhs.is_a?(java.math.BigDecimal)
-          # what a waste... using a QuantityType to multiply two dimensionless quantities
-          # have to make sure lhs is still a QuantityType in order to return a new
-          # QuantityType that's still dimensionless
-          lhs = other if lhs.is_a?(java.math.BigDecimal)
-
-          lhs.multiply(rhs)
-        end
-
-        alias divide_quantity divide
-      end
-    end
-  end
-end

data/lib/openhab/dsl/types/refresh_type.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module OpenHAB
-  module DSL
-    module Types
-      RefreshType = org.openhab.core.types.RefreshType
-
-      # Adds methods to core OpenHAB RefreshType to make it more natural in Ruby
-      class RefreshType # rubocop:disable Lint/EmptyClass
-        # @!parse include Type
-
-        # @!method refresh?
-        #   Check if == +REFRESH+
-        #   @return [Boolean]
-      end
-    end
-  end
-end

data/lib/openhab/dsl/types/rewind_fastforward_type.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module OpenHAB
-  module DSL
-    module Types
-      RewindFastforwardType = org.openhab.core.library.types.RewindFastforwardType
-
-      # Adds methods to core OpenHAB RewindFastforwardType to make it more
-      # natural in Ruby
-      class RewindFastforwardType # rubocop:disable Lint/EmptyClass
-        # @!parse include Type
-
-        # @!method rewinding?
-        #   Check if == +REWIND+
-        #   @return [Boolean]
-
-        # @!parse alias rewind? rewinding?
-
-        # @!method fast_forwarding?
-        #   Check if == +FASTFORWARD+
-        #   @return [Boolean]
-
-        # @!parse alias fast_forward? fast_forwarding?
-
-        # @deprecated
-        # @!parse alias fastforward? fast_forwarding?
-
-        # @deprecated
-        # @!parse alias fastforwarding? fast_forwarding?
-      end
-    end
-  end
-end

data/lib/openhab/dsl/types/stop_move_type.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module OpenHAB
-  module DSL
-    module Types
-      StopMoveType = org.openhab.core.library.types.StopMoveType
-
-      # Adds methods to core OpenHAB StopMoveType to make it more
-      # natural in Ruby
-      class StopMoveType # rubocop:disable Lint/EmptyClass
-        # @!parse include Type
-
-        # @!method stop?
-        #   Check if == +STOP+
-        #   @return [Boolean]
-
-        # @!method move?
-        #   Check if == +MOVE+
-        #   @return [Boolean]
-      end
-    end
-  end
-end

data/lib/openhab/dsl/types/types.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-require 'openhab/log/logger'
-
-require_relative 'type'
-
-require_relative 'date_time_type'
-require_relative 'decimal_type'
-require_relative 'hsb_type'
-require_relative 'increase_decrease_type'
-require_relative 'next_previous_type'
-require_relative 'open_closed_type'
-require_relative 'on_off_type'
-require_relative 'percent_type'
-require_relative 'play_pause_type'
-require_relative 'point_type'
-require_relative 'quantity_type'
-require_relative 'refresh_type'
-require_relative 'rewind_fastforward_type'
-require_relative 'stop_move_type'
-require_relative 'string_type'
-require_relative 'up_down_type'
-require_relative 'un_def_type'
-
-module OpenHAB
-  module DSL
-    # Hash taking a Enum value, and returning two symbols of
-    # predicates to be defined for it. the first is the "command" form,
-    # which should be defined on ItemCommandEvent, and on the Type itself.
-    # the second is "state" form, which should be defined on the applicable
-    # Item, and on the Type itself.
-    # @!visibility private
-    PREDICATE_ALIASES = Hash.new { |_h, k| [:"#{k.downcase}?"] * 2 }
-                            .merge({
-                                     'PLAY' => %i[play? playing?],
-                                     'PAUSE' => %i[pause? paused?],
-                                     'REWIND' => %i[rewind? rewinding?],
-                                     'FASTFORWARD' => %i[fast_forward? fast_forwarding?]
-                                   }).freeze
-
-    # Hash taking a Enum value, and returning an array of symbols
-    # of the command to define for it
-    # @!visibility private
-    COMMAND_ALIASES = Hash.new { |_h, k| k.downcase.to_sym }
-                          .merge({
-                                   'FASTFORWARD' => :fast_forward
-                                 }).freeze
-
-    #
-    # Contains all OpenHAB *Type classes, as well as associated support
-    # modules
-    #
-    module Types
-      include OpenHAB::Log
-
-      constants.map { |c| const_get(c) }
-               .grep(Module)
-               .select { |k| k < java.lang.Enum }
-               .each do |klass|
-        # make sure == from Type is inherited
-        klass.remove_method(:==)
-
-        # dynamically define predicate methods
-        klass.values.each do |value| # rubocop:disable Style/HashEachMethods this isn't a Ruby hash
-          # include all the aliases that we define for items both command and
-          # state aliases (since types can be interrogated as an incoming
-          # command, or as the state of an item)
-          command = :"#{OpenHAB::DSL::COMMAND_ALIASES[value.to_s]}?"
-          states = OpenHAB::DSL::PREDICATE_ALIASES[value.to_s]
-
-          ([command] | states).each do |method|
-            logger.trace("Defining #{klass}##{method} for #{value}")
-            klass.class_eval <<~RUBY, __FILE__, __LINE__ + 1
-              def #{method}       # def on?
-                self == #{value}  #   self == ON
-              end                 # end
-            RUBY
-          end
-        end
-      end
-    end
-  end
-end

data/lib/openhab/dsl/types/un_def_type.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module OpenHAB
-  module DSL
-    module Types
-      UnDefType = org.openhab.core.types.UnDefType
-
-      # Adds methods to core OpenHAB UnDefType to make it more natural in Ruby
-      class UnDefType # rubocop:disable Lint/EmptyClass
-        # @!parse include Type
-
-        # @!method null?
-        #   Check if == +NULL+
-        #   @return [Boolean]
-
-        # @!method undef?
-        #   Check if == +UNDEF+
-        #   @return [Boolean]
-      end
-    end
-  end
-end