openhab-jrubyscripting 5.0.0.rc1

data/lib/openhab/core/types/type.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module Core
+    module Types
+      # @interface
+      Type = org.openhab.core.types.Type
+
+      # @interface
+      Command = org.openhab.core.types.Command
+
+      # @interface
+      State = org.openhab.core.types.State
+
+      # This is a parent interface for all {State}s and {Command}s. It
+      # was introduced as many states can be commands at the same time and vice
+      # versa. E.g. a light can have the state {ON} or {OFF} and one can also
+      # send {ON} and {OFF} as commands to the device. This duality is captured
+      # by this marker interface and allows implementing classes to be both
+      # state and command at the same time.
+      module Type
+        # can't alias because to_s doesn't exist on Type
+        # @!visibility private
+        def inspect
+          to_s
+        end
+
+        #
+        # Type Coercion
+        #
+        # Coerce object to the same Type
+        #
+        # @param [Type] other object to coerce to the same
+        #   Type as this one
+        #
+        # @return [[Type, Type], nil]
+        #
+        def coerce(other)
+          logger.trace("Coercing #{self} (#{self.class}) as a request from #{other.class}")
+          return [other.as(self.class), self] if other.is_a?(Type) && other.respond_to?(:as)
+        end
+
+        #
+        # Check equality without type conversion
+        #
+        # @return [true,false] if the same value is represented, without type
+        #   conversion
+        def eql?(other)
+          return false unless other.instance_of?(self.class)
+
+          equals(other)
+        end
+
+        #
+        # Case equality
+        #
+        # @return [true,false] if the values are of the same Type
+        #                   or item state of the same type
+        #
+        def ===(other)
+          logger.trace { "Type (#{self.class}) #{self} === #{other} (#{other.class})" }
+          return false unless instance_of?(other.class)
+
+          eql?(other)
+        end
+
+        #
+        # Check equality, including type conversion
+        #
+        # @return [true,false] if the same value is represented, including
+        #   type conversions
+        #
+        def ==(other)
+          logger.trace { "(#{self.class}) #{self} == #{other} (#{other.class})" }
+          return true if equal?(other)
+
+          # i.e. ON == OFF, REFRESH == ON, ON == REFRESH
+          # (RefreshType isn't really coercible)
+          return equals(other) if other.instance_of?(self.class) || is_a?(RefreshType) || other.is_a?(RefreshType)
+
+          if other.respond_to?(:coerce)
+            begin
+              return false unless (lhs, rhs = other.coerce(self))
+            rescue TypeError
+              # this one is a bit odd. 50 (Integer) == ON is internally
+              # flipping the argument and calling this method. but it responds
+              # to coerce, and then raises a TypeError (from Float???) that
+              # it couldn't convert to OnOffType. it probably should have
+              # returned nil. catch it and return false instead
+              return false
+            end
+
+            return lhs == rhs
+          end
+
+          super
+        end
+      end
+
+      #
+      # @!parse
+      #   # This is a marker interface for all command types.
+      #   module Command
+      #     include Type
+      #   end
+      #
+      #   # This is a marker interface for all state types.
+      #   module State
+      #     include Type
+      #   end
+    end
+  end
+end
+
+# @!parse
+#   Command = OpenHAB::Core::Types::Command
+#   State = OpenHAB::Core::Types::State

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "type"
+
+module OpenHAB
+  module Core
+    module Types
+      UnDefType = org.openhab.core.types.UnDefType
+
+      # There are situations when item states do not have any defined value.
+      # This might be because they have not been initialized yet (never
+      # received an state update so far) or because their state is ambiguous
+      # (e.g. a group item with members whose states do not match will be
+      # {NULL}).
+      class UnDefType # rubocop:disable Lint/EmptyClass
+        # @!parse include State
+
+        # @!constant NULL
+        #   Null State
+        # @!constant UNDEF
+        #   Undef State
+
+        # @!method null?
+        #   Check if `self == NULL`
+        #   @return [true,false]
+
+        # @!method undef?
+        #   Check if `self == UNDEF`
+        #   @return [true,false]
+      end
+    end
+  end
+end
+
+# @!parse
+#   UnDefType = OpenHAB::Core::Types::UnDefType
+#   NULL = OpenHAB::Core::Types::UnDefType::NULL
+#   UNDEF = OpenHAB::Core::Types::UnDefType::UNDEF

data/lib/openhab/core/types/up_down_type.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "type"
+
+module OpenHAB
+  module Core
+    module Types
+      UpDownType = org.openhab.core.library.types.UpDownType
+
+      #
+      # Implements the {UP} and {DOWN} commands.
+      #
+      # Also, {PercentType} can be converted to {UpDownType}
+      # for more semantic comparisons. `0` is {UP}, `100` is
+      # {DOWN}, and anything in-between is neither.
+      #
+      class UpDownType
+        # @!parse include Command, State
+
+        # @!constant UP
+        #   Up Command/State
+        # @!constant DOWN
+        #   Down Command/State
+
+        # @!method up?
+        #   Check if `self == UP`
+        #   @return [true,false]
+
+        # @!method down?
+        #   Check if `self == DOWN`
+        #   @return [true,false]
+
+        #
+        # Invert the type
+        #
+        # @return [UpDownType] {UP} if {down?}, {DOWN} if {up?}
+        #
+        def !
+          return UP if down?
+          return DOWN if up?
+        end
+      end
+    end
+  end
+end
+
+# @!parse
+#   UpDownType = OpenHAB::Core::Types::UpDownType
+#   UP = OpenHAB::Core::Types::UpDownType::UP
+#   DOWN = OpenHAB::Core::Types::UpDownType::DOWN

data/lib/openhab/core/types.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+Dir[File.expand_path("types/*.rb", __dir__)].sort.each do |f|
+  require f
+end
+
+module OpenHAB
+  module Core
+    #
+    # Contains the core types that OpenHAB uses as {State}s for items, and
+    # {Command}s to be sent to control them.
+    #
+    # Types are the specific data types that commands and states are. They can be
+    # sent to items, be the current state of an item, or be the `command`, `state`,
+    # and `was` field of various
+    # {group::OpenHAB::DSL::Rules::Builder::Triggers triggers}.
+    # Some types have additional useful methods.
+    #
+    module Types
+      # 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
+
+      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 = :"#{Types::COMMAND_ALIASES[value.to_s]}?"
+          states = Types::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/core/uid.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module Core
+    java_import org.openhab.core.common.AbstractUID
+
+    # Adds methods to core OpenHAB AbstractUID to make it more natural in Ruby
+    class AbstractUID
+      # implicit conversion to string
+      alias_method :to_str, :to_s
+      # inspect result is just the string representation
+      alias_method :inspect, :to_s
+
+      # compares if equal to `other`, including string conversion
+      # @return [true, false]
+      def ==(other)
+        return true if equals(other)
+
+        to_s == other
+      end
+    end
+
+    # have to remove == from all descendant classes so that they'll inherit
+    # the new implementation
+    [org.openhab.core.items.MetadataKey,
+     org.openhab.core.thing.UID,
+     org.openhab.core.thing.ChannelUID,
+     org.openhab.core.thing.ChannelGroupUID,
+     org.openhab.core.thing.ThingUID,
+     org.openhab.core.thing.ThingTypeUID,
+     org.openhab.core.thing.type.ChannelTypeUID,
+     org.openhab.core.thing.type.ChannelGroupTypeUID].each do |klass|
+      klass.remove_method(:==)
+    end
+  end
+end

data/lib/openhab/core.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+Dir[File.expand_path("core/**/*.rb", __dir__)].sort.each do |f|
+  require f
+end
+
+module OpenHAB
+  # Contains classes and modules that wrap actual OpenHAB objects
+  module Core
+    # The OpenHAB Version. >= 3.3.0 is required.
+    # @return [String]
+    VERSION = org.openhab.core.OpenHAB.version.freeze
+
+    unless Gem::Version.new(VERSION) >= Gem::Version.new("3.3.0")
+      raise "`openhab-jrubyscripting` requires OpenHAB >= 3.3.0"
+    end
+
+    # @return [Integer] Number of seconds to wait between checks for automation manager
+    CHECK_DELAY = 10
+    private_constant :CHECK_DELAY
+    class << self
+      #
+      # Wait until OpenHAB engine ready to process
+      #
+      # @return [void]
+      #
+      # @!visibility private
+      def wait_till_openhab_ready
+        logger.trace("Checking readiness of OpenHAB")
+        until automation_manager
+          logger.trace("Automation manager not loaded, checking again in #{CHECK_DELAY} seconds.")
+          sleep CHECK_DELAY
+        end
+        logger.trace "Automation manager instantiated, OpenHAB ready for rule processing."
+      end
+
+      #
+      # @!attribute [r] config_folder
+      # @return [Pathname] The configuration folder path.
+      #
+      def config_folder
+        Pathname.new(org.openhab.core.OpenHAB.config_folder)
+      end
+
+      #
+      # JRuby isn't respecting $RUBYLIB when run embedded inside of OpenHAB, so do it manually
+      #
+      # @return [void]
+      #
+      # @!visibility private
+      def add_rubylib_to_load_path
+        ENV["RUBYLIB"]&.split(File::PATH_SEPARATOR)&.each do |path|
+          next if path.empty?
+
+          $LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)
+        end
+      end
+
+      #
+      # @!attribute [r] automation_manager
+      # @return [org.openhab.core.automation.module.script.rulesupport.shared.ScriptedAutomationManager]
+      #   The OpenHAB Automation manager.
+      #
+      def automation_manager
+        $scriptExtension.get("automationManager")
+      end
+
+      #
+      # @!attribute [r] rule_registry
+      # @return [org.openhab.core.automation.RuleRegistry] The OpenHAB rule registry
+      #
+      def rule_registry
+        $scriptExtension.get("ruleRegistry")
+      end
+
+      #
+      # @!attribute [r] rule_manager
+      # @return [org.openhab.core.automation.RuleManager] The OpenHAB rule manager/engine
+      #
+      def rule_manager
+        @rule_manager ||= OSGi.service("org.openhab.core.automation.RuleManager")
+      end
+    end
+  end
+end

data/lib/openhab/core_ext/java/duration.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module CoreExt
+    module Java
+      Duration = java.time.Duration
+
+      # Extensions to Duration
+      class Duration
+        # @!parse include TemporalAmount
+
+        alias_method :to_i, :seconds
+
+        #
+        # Convert to number of seconds
+        #
+        # @return [Float]
+        #
+        def to_f
+          to_i + (nano / 1_000_000_000.0)
+        end
+
+        remove_method :==
+
+        # @return [Integer, nil]
+        def <=>(other)
+          return to_f <=> other if other.is_a?(Numeric)
+
+          super
+        end
+
+        #
+        # Converts `other` to {Duration}, if possible.
+        #
+        # @param [Numeric, Period] other
+        # @return [Array, nil]
+        #
+        def coerce(other)
+          return [other.seconds, self] if other.is_a?(Numeric)
+          return [other.to_i.seconds, self] if other.is_a?(Period)
+        end
+
+        {
+          plus: :+,
+          minus: :-
+        }.each do |java_op, ruby_op|
+          # def +(other)
+          #   if other.is_a?(Duration)
+          #     plus(other)
+          #   elsif other.is_a?(Integer)
+          #     plus_seconds(other)
+          #   elsif other.is_a?(Numeric)
+          #     plus(other.seconds)
+          #   elsif other.respond_to?(:coerce) && (rhs, lhs = other.coerce(self))
+          #     lhs + rhs
+          #   else
+          #     raise TypeError, "#{other.class} can't be coerced into Duration"
+          #   end
+          # end
+          class_eval <<~RUBY, __FILE__, __LINE__ + 1 # rubocop:disable Style/DocumentDynamicEvalDefinition
+            def #{ruby_op}(other)
+              if other.is_a?(Duration)
+                #{java_op}(other)
+              elsif other.is_a?(Integer)
+                #{java_op}_seconds(other)
+              elsif other.is_a?(Numeric)
+                #{java_op}(other.seconds)
+              elsif other.respond_to?(:coerce) && (rhs, lhs = other.coerce(self))
+                lhs #{ruby_op} rhs
+              else
+                raise TypeError, "\#{other.class} can't be coerced into Duration"
+              end
+            end
+          RUBY
+        end
+
+        {
+          multipliedBy: :*,
+          dividedBy: :/
+        }.each do |java_op, ruby_op|
+          # def *(other)
+          #   if other.is_a?(Integer)
+          #     multipliedBy(other)
+          #   elsif other.is_a?(Numeric)
+          #     Duration.of_seconds(to_f * other)
+          #   elsif other.is_a?(Duration)
+          #     Duration.of_seconds(to_f * other.to_f)
+          #   elsif other.respond_to?(:coerce) && (rhs, lhs = other.coerce(self))
+          #     lhs * rhs
+          #   else
+          #     raise TypeError, "#{other.class} can't be coerced into Duration"
+          #   end
+          # end
+          class_eval <<~RUBY, __FILE__, __LINE__ + 1 # rubocop:disable Style/DocumentDynamicEvalDefinition
+            def #{ruby_op}(other)
+              if other.is_a?(Integer)
+                #{java_op}(other)
+              elsif other.is_a?(Numeric)
+                Duration.of_seconds(to_f #{ruby_op} other)
+              elsif other.is_a?(Duration)
+                Duration.of_seconds(to_f #{ruby_op} other.to_f)
+              elsif other.respond_to?(:coerce) && (rhs, lhs = other.coerce(self))
+                lhs #{ruby_op} rhs
+              else
+                raise TypeError, "\#{other.class} can't be coerced into Duration"
+              end
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end
+
+# @!parse Duration = OpenHAB::CoreExt::Java::Duration

data/lib/openhab/core_ext/java/local_date.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative "time"
+
+module OpenHAB
+  module CoreExt
+    module Java
+      java_import java.time.LocalDate
+
+      # Extensions to LocalDate
+      class LocalDate
+        include Time
+
+        class << self # rubocop:disable Lint/EmptyClass
+          # @!attribute [r] now
+          #   @return [ZonedDateTime]
+        end
+
+        # @param [TemporalAmount, LocalDate, Numeric] other
+        #   If other is a Numeric, it's interpreted as days.
+        # @return [LocalDate] If other is a TemporalAmount or Numeric
+        # @return [Period] If other is a LocalDate
+        def -(other)
+          case other
+          when Date
+            Period.of_days(day_of_year - other.yday)
+          when MonthDay
+            self - other.at_year(year)
+          when LocalDate
+            Period.of_days(day_of_year - other.day_of_year)
+          when Duration
+            minus_days(other.to_days)
+          when Numeric
+            minus_days(other.ceil)
+          else
+            minus(other)
+          end
+        end
+
+        # @param [TemporalAmount, Numeric] other
+        #   If other is a Numeric, it's interpreted as days.
+        # @return [LocalDate]
+        def +(other)
+          case other
+          when Duration
+            plus_days(other.to_days)
+          when Numeric
+            plus_days(other.to_i)
+          else
+            plus(other)
+          end
+        end
+
+        #
+        # Returns the next day
+        #
+        # @return [LocalDate]
+        #
+        def succ
+          plus_days(1)
+        end
+
+        # @return [Date]
+        def to_date
+          Date.new(year, month_value, day_of_month)
+        end
+
+        alias_method :to_month, :month
+
+        # @return [MonthDay]
+        def to_month_day
+          MonthDay.of(month, day_of_month)
+        end
+
+        # @return [self]
+        def to_local_date(_context = nil)
+          self
+        end
+
+        # @param [ZonedDateTime, nil] context
+        #   A {ZonedDateTime} used to fill in missing fields
+        #   during conversion. {ZonedDateTime.now} is assumed if not given.
+        # @return [ZonedDateTime]
+        def to_zoned_date_time(context = nil)
+          zone = context&.zone || java.time.ZoneId.system_default
+          at_start_of_day(zone)
+        end
+      end
+    end
+  end
+end
+
+LocalDate = OpenHAB::CoreExt::Java::LocalDate unless Object.const_defined?(:LocalDate)